diff --git a/wally-pipelined/src/fpu/FMA/align.sv b/wally-pipelined/src/fpu/FMA/align.sv index dbe9474f..e71f7147 100644 --- a/wally-pipelined/src/fpu/FMA/align.sv +++ b/wally-pipelined/src/fpu/FMA/align.sv @@ -64,35 +64,35 @@ module align(zman, ae, aligncnt, xzero, yzero, zzero, zdenorm, proddenorm, t, bs ps = 0; // And to using product as primary operand in adder I exponent gen - killprod = 0; + killprod = xzero | yzero; // d = aligncnt // p = 53 - if ($signed(aligncnt) <= $signed(-105)) begin //d<=-2p+1 + if ($signed(aligncnt) <= $signed(-103)) begin //d<=-2p+1 //product ancored case with saturated shift sumshift = 163; // 3p+4 sumshiftzero = 0; shift = {~zdenorm,zman,163'b0} >> sumshift; - t = {shift[215:52]}; + t = zzero ? 0 : {shift[215:52]}; bs = |(shift[51:0]); //zexpsel = 0; - end else if($signed(aligncnt) <= $signed(0)) begin // -2p+1> sumshift; - t = {shift[215:52]}; + t = zzero ? 0 : {shift[215:52]}; bs = |(shift[51:0]); //zexpsel = 0; - end else if ($signed(aligncnt)<=$signed(52)) begin // 2 < d <= p+2 + end else if ($signed(aligncnt)<=$signed(55)) begin // 2 < d <= p+2 // another typo in book? above was 55 changed to 52 // addend ancored case // used to be 56 \/ somthing doesn't seem right too many typos - sumshift = 55-aligncnt; + sumshift = 57-aligncnt; sumshiftzero = 0; shift = {~zdenorm,zman, 163'b0} >> sumshift; - t = {shift[215:52]}; + t = zzero ? 0 : {shift[215:52]}; bs = |(shift[51:0]); //zexpsel = 1; end else begin // d >= p+3 @@ -100,7 +100,7 @@ module align(zman, ae, aligncnt, xzero, yzero, zzero, zdenorm, proddenorm, t, bs sumshift = 0; sumshiftzero = 1; shift = {~zdenorm,zman, 163'b0} >> sumshift; - t = {shift[215:52]}; + t = zzero ? 0 : {shift[215:52]}; bs = |(shift[51:0]); killprod = 1; //ps = 1; diff --git a/wally-pipelined/src/fpu/FMA/expgen.sv b/wally-pipelined/src/fpu/FMA/expgen.sv index 104bdc23..15f5f8f7 100644 --- a/wally-pipelined/src/fpu/FMA/expgen.sv +++ b/wally-pipelined/src/fpu/FMA/expgen.sv @@ -84,8 +84,10 @@ module expgen(xexp, yexp, zexp, // This should not increas the critical path because the time to // check if a round overflows is shorter than the actual round and // is masked by the bypass mux and two 10 bit adder delays. - - assign aligncnt = zexp -ae - 1 + ~xdenorm + ~ydenorm - ~zdenorm; + assign aligncnt0 = - 1 + ~xdenorm + ~ydenorm - ~zdenorm; + assign aligncnt1 = - 1 + {12'b0,~xdenorm} + {12'b0,~ydenorm} - {12'b0,~zdenorm}; + assign aligncnt = zexp -ae - 1 + {12'b0,~xdenorm} + {12'b0,~ydenorm} - {12'b0,~zdenorm}; + //assign aligncnt = zexp -ae - 1 + ~xdenorm + ~ydenorm - ~zdenorm; //assign aligncnt = zexp - ae;// KEP use all of ae // Select exponent (usually from product except in case of huge addend) @@ -107,7 +109,7 @@ module expgen(xexp, yexp, zexp, // check for exponent out of bounds after add assign de = resultdenorm | sumzero ? 0 : de0; - assign sumof = de[12]; + assign sumof = ~de[12] && de > 2046; assign sumuf = de == 0 && ~sumzero && ~resultdenorm; // bypass occurs before rounding or taking early results diff --git a/wally-pipelined/src/fpu/FMA/flag.sv b/wally-pipelined/src/fpu/FMA/flag.sv index b8a2dc74..14ae0b5f 100644 --- a/wally-pipelined/src/fpu/FMA/flag.sv +++ b/wally-pipelined/src/fpu/FMA/flag.sv @@ -9,7 +9,7 @@ ///////////////////////////////////////////////////////////////////////////// module flag(xnan, ynan, znan, xinf, yinf, zinf, prodof, sumof, sumuf, - psign, zsign, xzero, yzero, vbits, + psign, zsign, xzero, yzero, zzero, vbits, killprod, inf, nan, invalid, overflow, underflow, inexact); ///////////////////////////////////////////////////////////////////////////// @@ -26,6 +26,8 @@ module flag(xnan, ynan, znan, xinf, yinf, zinf, prodof, sumof, sumuf, input zsign; // Sign of z input xzero; // x = 0 input yzero; // y = 0 + input zzero; // y = 0 + input killprod; input [1:0] vbits; // R and S bits of result output inf; // Some source is Inf output nan; // Some source is NaN @@ -73,8 +75,7 @@ module flag(xnan, ynan, znan, xinf, yinf, zinf, prodof, sumof, sumuf, // 1) Any input is denormalized // 2) Output would be denormalized or smaller - assign underflow = (sumuf && ~inf && ~prodinf && ~nan); - + assign underflow = (sumuf && ~inf && ~prodinf && ~nan) || (killprod & zzero & ~(yzero | xzero)); // Set the inexact flag for the following cases: // 1) Multiplication inexact diff --git a/wally-pipelined/src/fpu/FMA/normalize.sv b/wally-pipelined/src/fpu/FMA/normalize.sv index 5e7a4125..4ba01d95 100644 --- a/wally-pipelined/src/fpu/FMA/normalize.sv +++ b/wally-pipelined/src/fpu/FMA/normalize.sv @@ -47,7 +47,7 @@ module normalize(sum, zexp, invz, normcnt, ae, aligncnt, sumshift, sumshiftzero, logic [9:0] sumshifttmp; logic [163:0] sumshiftedtmp; // shifted sum logic sticky; -logic tmp,tmp1,tmp2,tmp3; +logic tmp,tmp1,tmp2,tmp3,tmp4, tmp5; // When the sum is zero, normalization does not apply and only the // sticky bit must be computed. Otherwise, the sum is right-shifted @@ -68,16 +68,16 @@ logic tmp,tmp1,tmp2,tmp3; // p = 53 // ea + eb = ae // set d<=2 to d<=0 - if ($signed(aligncnt)<=$signed(0)) begin //d<=2 + if ($signed(aligncnt)<=$signed(1)) begin //d<=2 // product anchored or cancellation if ($signed(ae-normcnt+2) >= $signed(-1022)) begin //ea+eb-l+2 >= emin //normal result - sumshifted = sum << (55+normcnt); // p+2+l + de0 = xzero|yzero ? zexp : ae-normcnt+2+xdenorm+ydenorm; + resultdenorm = |sum & ~|de0; + sumshifted = resultdenorm ? sum << sumshift : sum << (55+normcnt); // p+2+l v = sumshifted[162:109]; sticky = (|sumshifted[108:0]) | bs; - resultdenorm = 0; //de0 = ae-normcnt+2-1023; - de0 = xzero|yzero ? zexp : ae-normcnt+2+xdenorm+ydenorm; end else begin sumshifted = sum << (1080+ae); v = sumshifted[162:109]; @@ -87,38 +87,50 @@ logic tmp,tmp1,tmp2,tmp3; end end else begin // extract normalized bits - sumshifttmp = sumshift - 2; + sumshifttmp = {1'b0,sumshift} - 2; sumshifted = sumshifttmp[9] ? sum : sum << sumshifttmp; - tmp1 = (sumshifted[163] & ~zdenorm & ~sumshifttmp[9]); - tmp2 = (zdenorm | sumshifttmp[9] || sumshifted[162]); + tmp1 = (sumshifted[163] & ~sumshifttmp[9]); + tmp2 = (sumshifttmp[9] || sumshifted[162]); tmp3 = sumshifted[161]; + tmp4 = sumshifted[160]; + tmp5 = sumshifted[159]; // for some reason use exp = zexp + {0,1,2} // the book says exp = zexp + {-1,0,1} if(sumshiftzero) begin v = sum[162:109]; sticky = sum[108:0] | bs; de0 = zexp; - end else if(sumshifted[163] & ~zdenorm & ~sumshifttmp[9])begin + end else if(sumshifted[163] & ~sumshifttmp[9])begin v = sumshifted[162:109]; sticky = (|sumshifted[108:0]) | bs; de0 = zexp +2; - end else if (zdenorm | sumshifttmp[9] || sumshifted[162]) begin + end else if ((sumshifttmp[9] & sumshift[0]) || sumshifted[162]) begin v = sumshifted[161:108]; sticky = (|sumshifted[107:0]) | bs; de0 = zexp+1; - end else if (sumshifted[161]) begin + end else if (sumshifted[161] || (sumshifttmp[9] & sumshift[1])) begin v = sumshifted[160:107]; sticky = (|sumshifted[106:0]) | bs; //de0 = zexp-1; de0 = zexp; - end else begin + end else if(sumshifted[160]) begin v = sumshifted[159:106]; sticky = (|sumshifted[105:0]) | bs; //de0 = zexp-1; de0 = zexp-1; + end else if(sumshifted[159]) begin + v = sumshifted[158:105]; + sticky = (|sumshifted[104:0]) | bs; + //de0 = zexp-1; + de0 = zexp-2; + end else begin + v = sumshifted[160:107]; + sticky = (|sumshifted[106:0]) | bs; + //de0 = zexp-1; + de0 = zexp; end - resultdenorm = 0; + resultdenorm = ~(|de0); end end diff --git a/wally-pipelined/src/fpu/FMA/tbgen/results.dat b/wally-pipelined/src/fpu/FMA/tbgen/results.dat index c95e7771..4c8bd116 100644 --- a/wally-pipelined/src/fpu/FMA/tbgen/results.dat +++ b/wally-pipelined/src/fpu/FMA/tbgen/results.dat @@ -1,11 +1,16 @@ -8020007ffdffffff 9beffff7fff7fffe 000ffffffff7fffe 0000000000000000 000ffffffff7fffe Wrong zdenorm unflw 475303 -3cafffffffffffff 3fd0000000000000 3cafffffffffffff 3c8ffffffffffffb 3cb3ffffffffffff Wrong 706913 -bfbfffff007fffff 000fffffffffffff 000bffffffc00000 0015000007dc0000 000a00000fb80000 Wrong ydenorm zdenorm 1675647 -00114508bde544e1 3caffffffffffffe 800010000003fffe 801008000001fffe 800010000003fffd Wrong zdenorm 2310057 -800ffffffdffffff bfcffe00003ffffe 800ffff01ffffffe 80160018103bfbff 800c00302077f7ff Wrong xdenorm zdenorm 2475205 -bcafffffffffffff 3fd0000000000001 bcafffffffffffff bc8ffffffffffffd bcb4000000000000 Wrong 3776249 -bfc0000000800008 43d0001000000002 c3cffffbffff8000 c3a00000007e008a c3d20000000fc011 Wrong 3804445 -bfefffffffffffff 3fefffffffffffff bff0000000000001 b950000000000000 c000000000000000 Wrong 4338155 -37ea3353806450ba bffffffffffffffe b803fffffffff7ff b7c19a9c032205b3 b8108cd4e019102e Wrong 5143755 -8010000000803fff 3ff0000000000001 000fffe07fffffff fff0000000000000 8000001f80804001 Wrong zdenorm w=-inf 5246469 -b7fffff80000001f 001ffffffffffffe 800fffffffff07ff 8000000000000000 800fffffffff07ff Wrong w=-zero zdenorm unflw 5723787 +0010000000000000 bf4fdffffff7fffe 800ffffffffffffe 800003fbfffffefe 801003fbfffffefe Wrong zdenorm 308227 +0010000000000000 be6fffffbffffff7 8000000000000000 800000001fffffc0 800000000fffffe0 Wrong 313753 +001ffffffffffffe 3fddfbffffffffff 000ffffffffffffe 000efdfffffffffd 001efdfffffffffd Wrong zdenorm 551371 +3befe000ffffffff 800ffffffffffffe 0000000000000000 0000000000000000 8000000000000000 Wrong ydenorm unflw 665575 +000007fffffffffe 3f6ffffffe01fffe 000ffffffffffffe 00000007ffffff7e 00100007ffffff7e Wrong xdenorm zdenorm 768727 +3fdffffffffffffe 000ffffffffffffe 8000000000000001 7feffffffffffff6 0007fffffffffffe Wrong ydenorm zdenorm 1049939 +7fe0000000000001 4000000000000000 ffefffffffffffff 7ff0000000000000 7cb8000000000000 Wrong w=+inf 2602745 +000fff000000000f 3ff00800001fffff 8010000000000000 7f7bfe007ff8381e 000006ff801ffe0e Wrong xdenorm 3117277 +8000000000000001 40211275ffe5ee3c 0000000000000001 fcfe24ebffcbdc78 8000000000000008 Wrong xdenorm zdenorm 3148591 +801fffffffffffff bfdffffffffffffe 0000000000021fff 0000000000021ffe 0010000000021ffe Wrong zdenorm 3537867 +801ffffffffffffe 0010000000000001 0000000000000000 0000000000000000 8000000000000000 Wrong unflw 3564269 +bca0000000000001 000fffffc000001e 8000000000000000 8000000000000001 8000000000000000 Wrong ydenorm 3717769 +bcafffffffffffff 800ffffffffffffe 8000000000000000 0000000000000002 0000000000000001 Wrong ydenorm 3807413 +7fec5fed92358a74 400000001bffffff ffefc0003ffffffe 7ff0000000000000 7fe8ffdb47bad466 Wrong w=+inf 3889689 +bfdfffffffffffff 3fdf1f3616aa73e1 3fd0000000000001 3fd07064f4aac611 3f7c193d2ab1843f Wrong 4099063 +3fd07dfffffffffe 8010000000000001 0000000000000001 ffe07dfffffffffb 80041f7fffffffff Wrong zdenorm 4716133 diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tb b/wally-pipelined/src/fpu/FMA/tbgen/tb index 1e06e99b..47d4a1d2 100755 Binary files a/wally-pipelined/src/fpu/FMA/tbgen/tb and b/wally-pipelined/src/fpu/FMA/tbgen/tb differ diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tb.c b/wally-pipelined/src/fpu/FMA/tbgen/tb.c index a55d8023..fa3b5e71 100644 --- a/wally-pipelined/src/fpu/FMA/tbgen/tb.c +++ b/wally-pipelined/src/fpu/FMA/tbgen/tb.c @@ -26,13 +26,13 @@ void main() { char ans[81]; char flags[3]; int rn,rz,rm,rp; - long stop = 5723787; + long stop = 4099063; int debug = 1; //my_string = (char *) malloc (nbytes + 1); //bytes_read = getline (&my_string, &nbytes, stdin); - for(n=0; n < 2013; n++) {//613 for 10000 + for(n=0; n < 613; n++) {//613 for 10000 if(getline(&ln,&nbytes,fp) < 0 || feof(fp)) break; if(k == stop && debug == 1) break; k++; diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tb.v b/wally-pipelined/src/fpu/FMA/tbgen/tb.v index 1c9b75dd..55580c43 100644 --- a/wally-pipelined/src/fpu/FMA/tbgen/tb.v +++ b/wally-pipelined/src/fpu/FMA/tbgen/tb.v @@ -39,10 +39,10 @@ fmac UUT(.*); initial begin fp = $fopen("/home/kparry/riscv-wally/wally-pipelined/src/fpu/FMA/tbgen/results.dat","w"); - x = 64'hBFCFF800000000FF; - y = 64'h000FFFFFFFFFFFFF; - z = 64'h3FC7FEFFFFFFFFFE; - ans = 64'h3FC7FEFFFFFFFFFE; + x = 64'hC3E000000003FFFC; + y = 64'hB80E0000000FFFFE; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; rn = 1; rz = 0; rm = 0; @@ -84,59 +84,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2013\n"); - end - x = 64'h37F0000000014000; - y = 64'h37FFDFFFFFFFFF7F; - z = 64'h802FBFFFFFFFFEFF; - ans = 64'h2FFFE00000027CFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4027\n"); + $fwrite(fp,"613\n"); end x = 64'h0000000000000000; - y = 64'h001FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; + y = 64'h0000000000000001; + z = 64'hC1C88840B841DACF; + ans = 64'hC1C88840B841DACF; rn = 1; rz = 0; rm = 0; @@ -178,12 +131,482 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6041\n"); + $fwrite(fp,"1227\n"); end - x = 64'h36E0000000000028; + x = 64'h88800000803FFFFF; + y = 64'hC3D000001FFFDFFF; + z = 64'hBFB539DBC8083233; + ans = 64'hBFB539DBC8083233; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1841\n"); + end + x = 64'h27F0000008000004; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3CA0000000000000; + ans = 64'h3CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2455\n"); + end + x = 64'h0000000000000000; + y = 64'hBFABA4A2A8700F1E; + z = 64'hBC0FFFFF7FFFFFFD; + ans = 64'hBC0FFFFF7FFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3069\n"); + end + x = 64'hC1FFFFFFFFFF77FF; + y = 64'h0010000000000000; + z = 64'hC51B6366DC541E43; + ans = 64'hC51B6366DC541E43; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3683\n"); + end + x = 64'h0000000000000000; + y = 64'hC3DFE00040000000; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4297\n"); + end + x = 64'hBF6FFFFFFFF7F7FE; + y = 64'hC1C000000017FFFE; + z = 64'h3FBFFFFFFFFFFF7F; + ans = 64'h414000001013FBFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4911\n"); + end + x = 64'h0000000000000000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5525\n"); + end + x = 64'hB03C000000000006; + y = 64'h3810000020000003; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6139\n"); + end + x = 64'h0000000000000000; + y = 64'h3CA0000000000000; + z = 64'hBFC514F1AE3BBAA4; + ans = 64'hBFC514F1AE3BBAA4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6753\n"); + end + x = 64'h3FCDCBA8116A4E79; + y = 64'hB4EFF00100000000; + z = 64'h3F9000000000FDFE; + ans = 64'h3F9000000000FDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"7367\n"); + end + x = 64'hCF10000001000000; y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h3CA00008000FFFFE; - ans = 64'h3CA00008000FFFFE; + z = 64'h0010000000000001; + ans = 64'hCBD0000000FFFFFF; rn = 1; rz = 0; rm = 0; @@ -225,12 +648,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"8055\n"); + $fwrite(fp,"7981\n"); end - x = 64'hC0301FBFFFFFFFFF; - y = 64'h401000000000FFC0; - z = 64'hDB30000000020040; - ans = 64'hDB30000000020040; + x = 64'h0000000000000000; + y = 64'hBFCFFFFFFFFFEFBF; + z = 64'h37FA7539FC60F374; + ans = 64'h37FA7539FC60F374; rn = 1; rz = 0; rm = 0; @@ -272,12 +695,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"10069\n"); + $fwrite(fp,"8595\n"); + end + x = 64'h41CFFFFFFFFBFE00; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hFFDFFEFFFFFFBFFF; + ans = 64'hFFDFFEFFFFFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"9209\n"); + end + x = 64'h0000000000000000; + y = 64'hFFEFFFFFFFE03FFE; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"9823\n"); + end + x = 64'hC3CFFFFFFFFFFFDB; + y = 64'hC020001EFFFFFFFF; + z = 64'h41FFFFE0003FFFFF; + ans = 64'h4400001F000FFFDC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"10437\n"); + end + x = 64'h0000000000000000; + y = 64'h3FD0000000000001; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"11051\n"); + end + x = 64'h47FFFFFBFFFFFFC0; + y = 64'hBFE0000000600000; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hC7EFFFFC00BFFFA8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"11665\n"); end x = 64'h0000000000000000; y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; + z = 64'h3FE000000000100E; + ans = 64'h3FE000000000100E; rn = 1; rz = 0; rm = 0; @@ -319,12 +977,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"12083\n"); + $fwrite(fp,"12279\n"); end - x = 64'hA62FFFDBFFFFFFFE; + x = 64'h4070000001F80000; + y = 64'h3FE0000001FE0000; + z = 64'hBB81000001000000; + ans = 64'h4060000003F60000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"12893\n"); + end + x = 64'h3CA1000000000004; y = 64'h3FE0000000000001; - z = 64'hC1DFF7FC00000000; - ans = 64'hC1DFF7FC00000000; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h3C91000000000005; rn = 1; rz = 0; rm = 0; @@ -366,12 +1071,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"14097\n"); + $fwrite(fp,"13507\n"); end - x = 64'hBFD03FFFFFFFFFF0; - y = 64'h7FD6B970DE38813E; - z = 64'h3ECFEFFFFFFFFE00; - ans = 64'hFFB71456A1B1632C; + x = 64'h0000000000000000; + y = 64'h8011000000000000; + z = 64'h41EBFFFFFFF7FFFF; + ans = 64'h41EBFFFFFFF7FFFF; rn = 1; rz = 0; rm = 0; @@ -413,12 +1118,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"16111\n"); + $fwrite(fp,"14121\n"); + end + x = 64'h3FEFFFFFFEFFFFFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hC010000040001000; + ans = 64'hC008000080402001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"14735\n"); + end + x = 64'h0000000000000000; + y = 64'h43EFFFFFFFFFFDFF; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"15349\n"); + end + x = 64'h3FE9D75B0FC2F002; + y = 64'h3FDFFFFFFFF8003F; + z = 64'h4147CAF4689FF67D; + ans = 64'h4147CAF49C4EAC9C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"15963\n"); + end + x = 64'h0000000000000000; + y = 64'h3FF0000000000000; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"16577\n"); + end + x = 64'h41C0080000100000; + y = 64'hBCA7F7FFFFFFFFFE; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFE000003007F7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"17191\n"); end x = 64'h0000000000000000; y = 64'h3FFFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + z = 64'hC0AFFFBF7FFFFFFE; + ans = 64'hC0AFFFBF7FFFFFFE; rn = 1; rz = 0; rm = 0; @@ -460,12 +1400,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"18125\n"); + $fwrite(fp,"17805\n"); end - x = 64'h7FD0021FFFFFFFFF; - y = 64'h4000000000000001; - z = 64'h000FFFFFFFF8001F; - ans = 64'h7FE0022000000000; + x = 64'hBFF6F566DD405310; + y = 64'hC1F254DB3826CB07; + z = 64'h407FFFFFFFFFF7F8; + ans = 64'h41FA4DD6C47475B5; rn = 1; rz = 0; rm = 0; @@ -507,621 +1447,10 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"20139\n"); + $fwrite(fp,"18419\n"); end - x = 64'hFFFFFFF00007FFFE; - y = 64'h405FFFFFFFFFF83F; - z = 64'hC39000000001001E; - ans = 64'hFFFFFFF00007FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"22153\n"); - end - x = 64'h0000000000000000; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"24167\n"); - end - x = 64'h3FB9E0877FECE6BA; - y = 64'h4340000000000001; - z = 64'h80203FFFFFFFFF7F; - ans = 64'h4309E0877FECE6BC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"26181\n"); - end - x = 64'hC34E000020000000; - y = 64'h43C188DA7889EF54; - z = 64'h75FF807FFFFFFFFF; - ans = 64'h75FF807FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"28195\n"); - end - x = 64'h0000000000000000; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"30209\n"); - end - x = 64'hFB9FF7FFFFFFFBFF; - y = 64'h7FF0000000000000; - z = 64'hC34000013FFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"32223\n"); - end - x = 64'hFFDFFFF7FFF00000; - y = 64'hBC7FE21CD2A54D1F; - z = 64'h43DFEFF000000000; - ans = 64'h7C6FE214DA0E2767; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"34237\n"); - end - x = 64'h0000000000000000; - y = 64'h8000000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"36251\n"); - end - x = 64'hFFE00000001FFF00; - y = 64'h8010000000000000; - z = 64'h3FB9FFFFFFFFFFFF; - ans = 64'h4000D000001FFF00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"38265\n"); - end - x = 64'hC7E0800001000000; - y = 64'h41F0000007FFFFDF; - z = 64'hBFB0000080FFFFFF; - ans = 64'hC9E08000093FFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"40279\n"); - end - x = 64'h0000000000000000; - y = 64'hBCA0000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"42293\n"); - end - x = 64'h43D0000000FE0000; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'hC1D001FFFFFFFDFF; - ans = 64'hC1D00200FFFFFE0F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"44307\n"); - end - x = 64'h41EFFFFDFFFFFDFF; - y = 64'hFFFFFFFBFFEFFFFE; - z = 64'h7FF4282BA6C5B74F; - ans = 64'hFFFFFFFBFFEFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"46321\n"); - end - x = 64'h0000000000000000; - y = 64'hBFE0000000000000; + x = 64'h47500004000003FE; + y = 64'h3FFFFFFFFFFFFFFE; z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; @@ -1165,106 +1494,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"48335\n"); - end - x = 64'hB8016E821E7114DC; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hB7F000000001FFF7; - ans = 64'h37F2DD043CE029BF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"50349\n"); - end - x = 64'h43E85769B401F2FD; - y = 64'h4212E3E4695A36A4; - z = 64'hC020000002007FFF; - ans = 64'h460CBD0A941536A0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"52363\n"); + $fwrite(fp,"19033\n"); end x = 64'h0000000000000000; - y = 64'hC000000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; + y = 64'h456FFFFFFFFFFD7F; + z = 64'hBFE42BCBB894D499; + ans = 64'hBFE42BCBB894D499; rn = 1; rz = 0; rm = 0; @@ -1306,11 +1541,199 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"54377\n"); + $fwrite(fp,"19647\n"); end - x = 64'h7FE33C0E42D7B972; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hBFF0007FDFFFFFFE; + x = 64'h480E000000000001; + y = 64'h4000000000000001; + z = 64'h802FFFC007FFFFFE; + ans = 64'h481E000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"20261\n"); + end + x = 64'h0000000000000000; + y = 64'h4B13504F83E4334E; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"20875\n"); + end + x = 64'hB9607DFFFFFFFFFF; + y = 64'h3CADFFFFFFFFFFFE; + z = 64'hC39FFFFE00000003; + ans = 64'hC39FFFFE00000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"21489\n"); + end + x = 64'h0000000000000000; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"22103\n"); + end + x = 64'hC010200000000002; + y = 64'h7FE0080000001FFF; + z = 64'hBFD0000000000000; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -1353,12 +1776,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"56391\n"); + $fwrite(fp,"22717\n"); end - x = 64'hC3F94F46651EC7AE; - y = 64'hC3E3FFFFFFF00000; - z = 64'hB9EFFFFFDFFFFFFD; - ans = 64'h47EFA317FE4D2A53; + x = 64'h0000000000000000; + y = 64'h4010000000000001; + z = 64'h450000000001FFFE; + ans = 64'h450000000001FFFE; rn = 1; rz = 0; rm = 0; @@ -1400,10 +1823,621 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"58405\n"); + $fwrite(fp,"23331\n"); + end + x = 64'h47EFFFFFFFFFEFFE; + y = 64'hC01000FFFFFFFFFF; + z = 64'h3EBA653A07ABC2BC; + ans = 64'hC81000FFFFFFF7FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"23945\n"); + end + x = 64'hC0A2000000000FFF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"24559\n"); end x = 64'h0000000000000000; - y = 64'hC340000000000000; + y = 64'h453FFFFC001FFFFF; + z = 64'h313867979581E16A; + ans = 64'h313867979581E16A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"25173\n"); + end + x = 64'h419000000007FFF0; + y = 64'h4340000000000000; + z = 64'hC7FFFFDFF7FFFFFF; + ans = 64'hC7FFFFDFF7FFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"25787\n"); + end + x = 64'h0000000000000000; + y = 64'hA5FFFFFFDFFFFFFE; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"26401\n"); + end + x = 64'hB80000000000047F; + y = 64'hC7EFFFFFFFDFFEFF; + z = 64'hBFEF800000000FFF; + ans = 64'h3FF03FFFFFDFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"27015\n"); + end + x = 64'h0000000000000000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"27629\n"); + end + x = 64'h86A0000000050000; + y = 64'h2AD69B1275E503A0; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"28243\n"); + end + x = 64'h0000000000000000; + y = 64'h7FE0000000000000; + z = 64'hBFF82D736AB2577D; + ans = 64'hBFF82D736AB2577D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"28857\n"); + end + x = 64'h43DD6D4736825F34; + y = 64'h11E0080000000200; + z = 64'hB2E0000000020000; + ans = 64'hB2E0000000020000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"29471\n"); + end + x = 64'hB7EE3604B4C64B15; + y = 64'h7FE0000000000001; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"30085\n"); + end + x = 64'h0000000000000000; + y = 64'hC00FBFFFFFFFFFFE; + z = 64'h4010000400020000; + ans = 64'h4010000400020000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"30699\n"); + end + x = 64'hBE1200001FFFFFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h40E56C3F5EA1E0BD; + ans = 64'hFE1200001FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"31313\n"); + end + x = 64'h0000000000000000; + y = 64'h47F44C67CE14725C; z = 64'h3FF0000000000001; ans = 64'h3FF0000000000001; rn = 1; @@ -1447,12 +2481,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"60419\n"); + $fwrite(fp,"31927\n"); end - x = 64'hBE10000800000FFF; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hFFD9DB5021932540; - ans = 64'hFFD9DB5021932540; + x = 64'hBF4F00000000001E; + y = 64'hC1EFFFFFFFFFF000; + z = 64'hB4B05C323E215212; + ans = 64'h414EFFFFFFFFF09E; rn = 1; rz = 0; rm = 0; @@ -1494,904 +2528,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"62433\n"); - end - x = 64'h43EF00001FFFFFFF; - y = 64'hC6BFFFFF00001FFE; - z = 64'hD720004001000000; - ans = 64'hD720004001000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"64447\n"); + $fwrite(fp,"32541\n"); end x = 64'h0000000000000000; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"66461\n"); - end - x = 64'h47EDBFD0A1EAAB89; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h400FFFFFF7FFFDFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"68475\n"); - end - x = 64'h400FFFF008000000; - y = 64'hC0140007FFFFFFFF; - z = 64'h3CA0FFFFFFFFEFFF; - ans = 64'hC033FFFE04FC01FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"70489\n"); - end - x = 64'h0000000000000001; - y = 64'h000FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"72503\n"); - end - x = 64'h47F0000800000FFF; - y = 64'h001FFFFFFFFFFFFF; - z = 64'hB7F020000000007E; - ans = 64'hB7F020000000007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"74517\n"); - end - x = 64'hB35E0000003FFFFF; - y = 64'h30DFFF6000000000; - z = 64'hBFCFFFFF7FFFF000; - ans = 64'hBFCFFFFF7FFFF000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"76531\n"); - end - x = 64'h0000000000000001; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"78545\n"); - end - x = 64'h43DFE45B42DC9C12; - y = 64'h3FD0000000000001; - z = 64'h2DC0000100000008; - ans = 64'h43BFE45B42DC9C14; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"80559\n"); - end - x = 64'hC676C2C0D7DB1BC4; - y = 64'hC7E3FFFFFFDFFFFF; - z = 64'h43CBF8649B07D35D; - ans = 64'h4E6C73710DA45D32; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"82573\n"); - end - x = 64'h0000000000000001; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"84587\n"); - end - x = 64'hC3C0271F93496A51; - y = 64'h3FF0000000000001; - z = 64'hBFC339EF066EE599; - ans = 64'hC3C0271F93496A52; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"86601\n"); - end - x = 64'hC023E6C8B89C7367; - y = 64'hC1FEFFFFFFFFFFFA; - z = 64'h9A52001FFFFFFFFF; - ans = 64'h4233479272D78FC8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"88615\n"); - end - x = 64'h0000000000000001; - y = 64'h400FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"90629\n"); - end - x = 64'hCF6C878C67E3CCF9; - y = 64'h4010000000000000; - z = 64'hC0EFFFF804000000; - ans = 64'hCF8C878C67E3CCF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"92643\n"); - end - x = 64'h3FEFFFF77FFFFFFF; - y = 64'hBFC0003FFFFFFFBE; - z = 64'h40200000FFFBFFFF; - ans = 64'h401F800021F88800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"94657\n"); - end - x = 64'h0000000000000001; - y = 64'h4340000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"96671\n"); - end - x = 64'hB94000000017FFFF; - y = 64'h7FE0000000000000; - z = 64'hBE5FFDBFFFFFFFFF; - ans = 64'hF93000000017FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"98685\n"); - end - x = 64'h47F0007FFFFFFFFB; - y = 64'h7FD000007FFDFFFF; - z = 64'h41CFFFF00003FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"100699\n"); - end - x = 64'h0000000000000001; y = 64'h7FF0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; + z = 64'hC000000000000001; ans = 64'h7FF8000000000001; rn = 1; rz = 0; @@ -2434,12 +2575,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"102713\n"); + $fwrite(fp,"33155\n"); end - x = 64'hC12BFFFFFFFFFFBE; - y = 64'h8000000000000000; - z = 64'hC3C0000000000000; - ans = 64'hC3C0000000000000; + x = 64'hBFE828460CDF6B0D; + y = 64'hADAFFBFFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h2DA82541041DCF1F; rn = 1; rz = 0; rm = 0; @@ -2481,3207 +2622,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"104727\n"); + $fwrite(fp,"33769\n"); end - x = 64'hC34000000001FBFF; - y = 64'hEC30000000001080; - z = 64'hBFFFFFFFFF7FF800; - ans = 64'h6F80000000020C7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"106741\n"); - end - x = 64'h0000000000000001; - y = 64'h8010000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"108755\n"); - end - x = 64'hC80FFFF800000000; - y = 64'h801FFFFFFFFFFFFE; - z = 64'hC0098E4ADD5BCBCE; - ans = 64'hC0098E4ADD5BCBCE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"110769\n"); - end - x = 64'hB80FFFFFFFFFFFFE; - y = 64'h401FFBFFFFFFFFEE; - z = 64'h401000000000FDFF; - ans = 64'h401000000000FDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"112783\n"); - end - x = 64'h0000000000000001; - y = 64'hBFD0000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"114797\n"); - end - x = 64'hBF4C6D05FF900C3F; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'h47FB82667FA1F31C; - ans = 64'h47FB82667FA1F31C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"116811\n"); - end - x = 64'hC0003FFFFFFFFF7F; - y = 64'h37EFFFFFFE004000; - z = 64'h381E29836BC8D7F8; - ans = 64'h381609836C4AC7F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"118825\n"); - end - x = 64'h0000000000000001; - y = 64'hBFF0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"120839\n"); - end - x = 64'hF99FFFFFFFFBFFFB; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hBFE17FFFFFFFFFFF; - ans = 64'h79AFFFFFFFFBFFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"122853\n"); - end - x = 64'h43F00000000003FF; - y = 64'h303FFFE000000002; - z = 64'hBFF00000000083FF; - ans = 64'hBFF00000000083FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"124867\n"); - end - x = 64'h0000000000000001; - y = 64'hC010000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"126881\n"); - end - x = 64'hBE5BFFFFFFFFEFFE; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h3FF7C1136E8AA3CA; - ans = 64'h3FF7C113A68AA3CA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"128895\n"); - end - x = 64'h409F8000003FFFFF; - y = 64'h3B6FEFFFFFFFFFFD; - z = 64'hC01001FFEFFFFFFF; - ans = 64'hC01001FFEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"130909\n"); - end - x = 64'h0000000000000001; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"132923\n"); - end - x = 64'h429FFFDFFFFEFFFE; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'h402FE0000000007F; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"134937\n"); - end - x = 64'hBF3000000DFFFFFF; - y = 64'hBF8000040007FFFE; - z = 64'h0197F2FDF4257279; - ans = 64'h3EC000040E08037D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"136951\n"); - end - x = 64'h0000000000000001; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"138965\n"); - end - x = 64'hC005937FE4462628; - y = 64'h0000000000000001; - z = 64'hC24FF9FFFFFFFFFE; - ans = 64'hC24FF9FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"140979\n"); - end - x = 64'h802F9AD608A7A076; - y = 64'hFFF0000001FFF7FF; - z = 64'h3BBFFFFFFFBFFFBE; - ans = 64'hFFF8000001FFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"142993\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"145007\n"); - end - x = 64'h423FDFC000000000; - y = 64'h3CA0000000000001; - z = 64'hC00584E2101BE3EF; - ans = 64'hC00584DA182BE3EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"147021\n"); - end - x = 64'hC03C54BD6921B05D; - y = 64'hC02FE007FFFFFFFF; - z = 64'hC0020B6D2412FDF2; - ans = 64'h407C1458E69FC2F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"149035\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"151049\n"); - end - x = 64'h375FE20000000000; - y = 64'h3FE0000000000001; - z = 64'hB46FFFFFFFFE0010; - ans = 64'h374FE1FFFFFFFF82; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"153063\n"); - end - x = 64'h403FFFFFE001FFFF; - y = 64'h3E5DAA9BEBA734CA; - z = 64'h4023FE0E11BE1E1E; - ans = 64'h4023FE0E2F68B9EC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"155077\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"157091\n"); - end - x = 64'h40E200000000003F; - y = 64'h4000000000000000; - z = 64'h41CFFFFFFFFFFDFE; - ans = 64'h41D00047FFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"159105\n"); - end - x = 64'h3FDFFE0000001FFF; - y = 64'hC7EF000000000020; - z = 64'h41DFFFFFFFFFBEFF; - ans = 64'hC7DEFE1000001F1F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"161119\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'h4010000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"163133\n"); - end - x = 64'h47EC49A3B6FE1E05; - y = 64'h4340000000000000; - z = 64'hC7F00001FFFF7FFF; - ans = 64'h4B3C49A3B6FE1E04; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"165147\n"); - end - x = 64'hBA5BFFFFFFFBFFFF; - y = 64'hC3EFF8F4A38946A4; - z = 64'hC03FFFFFBFFFC000; - ans = 64'hC03FFFFFBF8FD8A8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"167161\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'h7FE0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"169175\n"); - end - x = 64'h3FBFFFFFFFFFFFFA; - y = 64'h7FF0000000000000; - z = 64'h3801FFFFEFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"171189\n"); - end - x = 64'h50AAFE7C26407D06; - y = 64'h3FFDFFF7FFFFFFFF; - z = 64'h0E058C435455CC58; - ans = 64'h50B94E8DA43D6BA5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"173203\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'h8000000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"175217\n"); - end - x = 64'h43C001FFFFFFFDFF; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hC1C000007E000000; - ans = 64'hC1C000007E000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"177231\n"); - end - x = 64'h43D0000000004200; - y = 64'hFFDFFFF800000020; - z = 64'hC3EFFFFFFE7FFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"179245\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'hBCA0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"181259\n"); - end - x = 64'h3FFFFFFFFFEFBFFF; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h371FFDFFFBFFFFFF; - ans = 64'hBCBFFFFFFFEFBFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"183273\n"); - end - x = 64'h3FCFFFFFFFF10000; - y = 64'h3E9FFCFFFFFFFFFE; - z = 64'h37FFFFFFFFF001FF; - ans = 64'h3E7FFCFFFFF10166; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"185287\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'hBFE0000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"187301\n"); - end - x = 64'hC1D8003FFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hB4200100007FFFFF; - ans = 64'h41D8003FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"189315\n"); - end - x = 64'h43F08000003FFFFF; - y = 64'h43F0000000010007; - z = 64'h3FD000008000003F; - ans = 64'h47F0800000410806; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"191329\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"193343\n"); - end - x = 64'hC42DB91340AF93D0; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h6A0000000000FF7F; - ans = 64'h6A0000000000FF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"195357\n"); - end - x = 64'h4FC00020003FFFFF; - y = 64'h0020000002003FFF; - z = 64'h57B00000000FC000; - ans = 64'h57B00000000FC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"197371\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"199385\n"); - end - x = 64'h7FE0400000800000; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'h43FFFFFDFFFFFFBF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"201399\n"); - end - x = 64'h3F8CD1CDC67650EA; - y = 64'hC017EFFFFFFFFFFE; - z = 64'h43CFFDEFFFFFFFFF; - ans = 64'h43CFFDEFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"203413\n"); - end - x = 64'h000FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'hC007FFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"205427\n"); - end - x = 64'h924ADC0D0C7D8041; - y = 64'hFFF0000000000001; - z = 64'h3FBFFEFFFFFEFFFE; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"207441\n"); - end - x = 64'h3FBFFFFFFFFC0003; - y = 64'h43F0200000004000; - z = 64'h3FC9E8FB1845E2EC; - ans = 64'h43C01FFFFFFE3C02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"209455\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"211469\n"); - end - x = 64'hC041C7DCE2709A19; - y = 64'h0010000000000001; - z = 64'h3FCF7FFFFFF00000; - ans = 64'h3FCF7FFFFFF00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"213483\n"); - end - x = 64'h380C374E4A521601; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h43CFFF80001FFFFF; - ans = 64'h43CFFF80001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"215497\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"217511\n"); - end - x = 64'h7FF1C6B1098FF7F7; - y = 64'h3FD0000000000001; - z = 64'hC80FFC007FFFFFFE; - ans = 64'h7FF9C6B1098FF7F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"219525\n"); - end - x = 64'hC01000000FFFFFFE; - y = 64'hF6EFFFFFF000FFFF; - z = 64'h41EFFE0080000000; - ans = 64'h7710000008007FF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"221539\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"223553\n"); - end - x = 64'h43DC9799AEAC7B3A; - y = 64'h3FF0000000000000; - z = 64'hC0FFF7FFFFFFFFFF; - ans = 64'h43DC9799AEAC7ABA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"225567\n"); - end - x = 64'h3FDE39086553EEEC; - y = 64'hDF9221710B73E617; - z = 64'h3EEE6111637E2863; - ans = 64'hDF811FAA4DDE6BEC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"227581\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'h4000000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"229595\n"); - end - x = 64'h3FFFFF7FFDFFFFFF; - y = 64'h4010000000000000; - z = 64'h47748A41CB17831D; - ans = 64'h47748A41CB17831D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"231609\n"); - end - x = 64'hC0D0FFFFFFFFFE00; - y = 64'h3F3FFFF800800000; - z = 64'h0018661007BF7450; - ans = 64'hC020FFFBC043FE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"233623\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'h4340000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"235637\n"); - end - x = 64'h37EFFFFFFC800000; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hC1C623C26A784CB7; - ans = 64'hC1C623C26A784CB7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"237651\n"); - end - x = 64'h40A20007FFFFFFFF; - y = 64'h41DFFFEFFFFFFFFD; - z = 64'h5123A0479A820274; - ans = 64'h5123A0479A820274; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"239665\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'h7FF0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"241679\n"); - end - x = 64'h3C0FFEFFFDFFFFFF; + x = 64'h0000000000000000; y = 64'h7FFFFFFFFFFFFFFE; - z = 64'h40775445C2C8E6E5; + z = 64'h4007FFFFFFFFFC00; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -5724,12 +2669,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"243693\n"); + $fwrite(fp,"34383\n"); end - x = 64'hBCAFFC0000000FFE; - y = 64'hC0100000001FFFFB; - z = 64'hBFCFFFF7FFFFBFFE; - ans = 64'hBFCFFFF7FFFFBFDE; + x = 64'hC7FFFFFFFFFFFFE7; + y = 64'hC7EFFFFEFFFFFFF8; + z = 64'hBFF0003C00000000; + ans = 64'h4FFFFFFEFFFFFFDF; rn = 1; rz = 0; rm = 0; @@ -5771,1563 +2716,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"245707\n"); + $fwrite(fp,"34997\n"); end - x = 64'h000FFFFFFFFFFFFE; - y = 64'h8010000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"247721\n"); - end - x = 64'h801FFEFFFFFFEFFE; - y = 64'h801FFFFFFFFFFFFE; - z = 64'hC06000007FBFFFFE; - ans = 64'hC06000007FBFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"249735\n"); - end - x = 64'h3CA80000000000FE; - y = 64'h8017FB4D2CCAA271; - z = 64'h3F6000000010000F; - ans = 64'h3F6000000010000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"251749\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'hBFD0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"253763\n"); - end - x = 64'h403000000000080E; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hC05DFFF800000000; - ans = 64'hC05FFFF800000102; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"255777\n"); - end - x = 64'h3CA000000FFFF800; - y = 64'h243EFFDFFFFFFFFF; - z = 64'hBEB03FFFFFBFFFFE; - ans = 64'hBEB03FFFFFBFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"257791\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"259805\n"); - end - x = 64'h412007FFFEFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h4012000040000000; - ans = 64'hC13007FB7EFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"261819\n"); - end - x = 64'h3FC0000003F7FFFE; - y = 64'h2C00FF7FFFFFFFFF; - z = 64'hBCBFFFFFFFFE7FFF; - ans = 64'hBCBFFFFFFFFE7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"263833\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"265847\n"); - end - x = 64'h47F0000800001FFF; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'hB81FDFFFFFFFEFFE; - ans = 64'hC820000800001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"267861\n"); - end - x = 64'h3FD0000FFFF7FFFE; - y = 64'h308FFFFFFBFFFFFD; - z = 64'h40000000003FFFFC; - ans = 64'h40000000003FFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"269875\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"271889\n"); - end - x = 64'h41CFFFFFF0003FFF; - y = 64'hFFE0000000000001; - z = 64'h409FFF0003FFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"273903\n"); - end - x = 64'hB8092EC54A99590C; - y = 64'h3D9ED2D3EF3AB013; - z = 64'h3FE00001FFFFFBFF; - ans = 64'h3FE00001FFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"275917\n"); - end - x = 64'h000FFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"277931\n"); - end - x = 64'hFFDF0195428D1378; - y = 64'h0000000000000001; - z = 64'hFFE0000500000000; - ans = 64'hFFE0000500000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"279945\n"); - end - x = 64'hBFE200000000FFFE; - y = 64'h41FD6E4653630B63; - z = 64'h480FFFF008000000; - ans = 64'h480FFFF008000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"281959\n"); - end - x = 64'h0010000000000000; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"283973\n"); - end - x = 64'h3CA5FFFFFFFFFFFF; - y = 64'h3CA0000000000000; - z = 64'h3FDFFE0000007FFE; - ans = 64'h3FDFFE0000007FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"285987\n"); - end - x = 64'hA4C1CB8F4C4A2248; - y = 64'h3F6DFFFDFFFFFFFF; - z = 64'h43CFFFFFFFFFF001; - ans = 64'h43CFFFFFFFFFF001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"288001\n"); - end - x = 64'h0010000000000000; - y = 64'h3FD0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"290015\n"); - end - x = 64'hC7EFF7FFFDFFFFFF; - y = 64'h3FE0000000000000; - z = 64'h45BFFFFFF7FFFE00; - ans = 64'hC7DFF7FFFDF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"292029\n"); - end - x = 64'h3FC0DC6ED2EAFE1A; - y = 64'h9D30004000000080; - z = 64'h402FFFFF7FFC0000; - ans = 64'h402FFFFF7FFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"294043\n"); - end - x = 64'h0010000000000000; - y = 64'h3FF0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"296057\n"); - end - x = 64'hFFD0001FFFEFFFFF; - y = 64'h4000000000000000; - z = 64'hB9DFFFFFFBFFF800; - ans = 64'hFFE0001FFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"298071\n"); - end - x = 64'h3FEFFF7FFFFEFFFF; - y = 64'h41E0001003FFFFFF; - z = 64'hC074811E0051B61D; - ans = 64'h41DFFF9FB57A67FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"300085\n"); - end - x = 64'h0010000000000000; - y = 64'h4010000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"302099\n"); - end - x = 64'hBFDFFFFFB0000000; - y = 64'h401FFFFFFFFFFFFE; - z = 64'h4000000800003FFF; - ans = 64'hBFFFFFEF5FFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"304113\n"); - end - x = 64'h403002000003FFFF; - y = 64'h43C00FFBFFFFFFFF; - z = 64'h3FB000401FFFFFFE; - ans = 64'h440011FDFF8403FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"306127\n"); - end - x = 64'h0010000000000000; - y = 64'h7FE0000000000000; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"308141\n"); - end - x = 64'h402FBFFFFFFFBFFF; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'h47F7B2028F6F437D; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"310155\n"); - end - x = 64'hC02FFFFFFFBFFFFF; - y = 64'hB39FFFFFFFFFF808; - z = 64'h43FFFFF000002000; - ans = 64'h43FFFFF000002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"312169\n"); - end - x = 64'h0010000000000000; + x = 64'hBC500BFFFFFFFFFF; y = 64'h8000000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -7369,12 +2763,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"314183\n"); + $fwrite(fp,"35611\n"); end - x = 64'hC1DBFFFFFFFF7FFF; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h37FFFDFFFFFFFF00; - ans = 64'h37FFFDFFFFFFFF00; + x = 64'h0000000000000000; + y = 64'hC01000000000080E; + z = 64'hCE9F800000FFFFFF; + ans = 64'hCE9F800000FFFFFF; rn = 1; rz = 0; rm = 0; @@ -7416,3208 +2810,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"316197\n"); + $fwrite(fp,"36225\n"); end - x = 64'hC3FA269DD2690536; - y = 64'hC80200007FFFFFFE; - z = 64'h3F1000FFFFBFFFFF; - ans = 64'h4C0D6B725DEB146D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"318211\n"); - end - x = 64'h0010000000000000; - y = 64'hBCA0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"320225\n"); - end - x = 64'hC09000003FFFBFFF; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hC02FFFFFFFFE01FF; - ans = 64'hC02FFFFFFFFE017F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"322239\n"); - end - x = 64'h000FFFEFFFFFFFEF; - y = 64'h3CD08A79FF518287; - z = 64'h41B00000002000FF; - ans = 64'h41B00000002000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"324253\n"); - end - x = 64'h0010000000000000; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"326267\n"); - end - x = 64'h5120000080000FFF; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hBFBC00000000003F; - ans = 64'hD120000080000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"328281\n"); - end - x = 64'hBA50000002001000; - y = 64'hC790000000000407; - z = 64'hB150002003FFFFFF; - ans = 64'h41F0000002001407; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"330295\n"); - end - x = 64'h0010000000000000; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"332309\n"); - end - x = 64'hBEEF802000000000; - y = 64'hC000000000000001; - z = 64'h4000000000DFFFFF; - ans = 64'h4000000FC0EFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"334323\n"); - end - x = 64'hBDFFFFF8000000FE; - y = 64'hBA37EF95F9E7FCB2; - z = 64'hBA2FC000007FFFFF; - ans = 64'hBA2FC000002041BF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"336337\n"); - end - x = 64'h0010000000000000; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"338351\n"); - end - x = 64'hBFE7DA39E756FAB8; - y = 64'hC340000000000001; - z = 64'h41D87200E15761BA; - ans = 64'h4337DA3A491EFE3F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"340365\n"); - end - x = 64'h39EFFFF000000040; - y = 64'hBFA0000000020FFF; - z = 64'hBD117042903CB8AA; - ans = 64'hBD117042903CB8AA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"342379\n"); - end - x = 64'h0010000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"344393\n"); - end - x = 64'hB2AFFE2000000000; - y = 64'hFFF0000000000001; - z = 64'h000FFEFFFFE00000; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"346407\n"); - end - x = 64'hBF4FF8000003FFFF; - y = 64'h400FC000000001FF; - z = 64'hBFD1000000040000; - ans = 64'hBFD13F70200407F4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"348421\n"); - end - x = 64'h0010000000000001; - y = 64'h000FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"350435\n"); - end - x = 64'h417FFF7FFFFFFF00; - y = 64'h0010000000000000; - z = 64'h37FA53BB21817EC2; - ans = 64'h37FA53BB21817EC2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"352449\n"); - end - x = 64'h480FFC0100000000; - y = 64'h46F0000001007FFF; - z = 64'hC010000000000000; - ans = 64'h4F0FFC010200BFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"354463\n"); - end - x = 64'h0010000000000001; - y = 64'h3CA0000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"356477\n"); - end - x = 64'h43FAE7911860836B; - y = 64'h3FD0000000000000; - z = 64'h25D0478B318DBCB2; - ans = 64'h43DAE7911860836B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"358491\n"); - end - x = 64'hC28FF7EFFFFFFFFF; - y = 64'hFFE0000000001EFE; - z = 64'hC5E000000FFFFFBF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"360505\n"); - end - x = 64'h0010000000000001; - y = 64'h3FE0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"362519\n"); - end - x = 64'hBF3FE0003FFFFFFE; - y = 64'h3FF0000000000000; - z = 64'hBD83FFFFFFFFFFFE; - ans = 64'hBF3FE000427FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"364533\n"); - end - x = 64'h3FD00403FFFFFFFE; - y = 64'h25BFF00000100000; - z = 64'hBF6003FFFFFFFFFB; - ans = 64'hBF6003FFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"366547\n"); - end - x = 64'h0010000000000001; - y = 64'h4000000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"368561\n"); - end - x = 64'h38F986D8EF088441; - y = 64'h400FFFFFFFFFFFFE; - z = 64'hB806D62A6ADF932D; - ans = 64'h391986CD83F34ED0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"370575\n"); - end - x = 64'h52CFFFEFFFFFFBFE; - y = 64'hC3DCF5E2283E4645; - z = 64'h3FDFFFC004000000; - ans = 64'hD6BCF5D3AD4D2E85; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"372589\n"); - end - x = 64'h0010000000000001; - y = 64'h4340000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"374603\n"); - end - x = 64'h3D50FFFFFFFFFBFF; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hC13FF000007FFFFF; - ans = 64'hC13FDF0000800003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"376617\n"); - end - x = 64'hFA10007FFFFFFF7E; - y = 64'h80025B95F6F2AE19; - z = 64'hC2B00000000403FF; - ans = 64'hC2B00000000403FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"378631\n"); - end - x = 64'h0010000000000001; - y = 64'h7FF0000000000000; - z = 64'h4340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"380645\n"); - end - x = 64'h3800000800000003; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'h4020AE1F9ECA9031; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"382659\n"); - end - x = 64'h2703A2471F27E3E3; - y = 64'hC03AEB1CF89CD9EB; - z = 64'h3FF007FFFFDFFFFF; - ans = 64'h3FF007FFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"384673\n"); - end - x = 64'h0010000000000001; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"386687\n"); - end - x = 64'h40000FEFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - z = 64'h4D3FFFFFFFC00080; - ans = 64'h4D3FFFFFFFC00080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"388701\n"); - end - x = 64'h43CCA7AE5B9D672B; - y = 64'hC803D86978A18D8C; - z = 64'h4020180000000000; - ans = 64'hCBE1C559D1897093; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"390715\n"); - end - x = 64'h0010000000000001; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"392729\n"); - end - x = 64'h7FD01003FFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hBF8FFFFDBFFFFFFF; - ans = 64'hFFC01003FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"394743\n"); - end - x = 64'hC1C007FFFFFFFF7F; - y = 64'hC7EFFFFFFFFC1FFF; - z = 64'h47FFFFFFFF800001; - ans = 64'h49C0080000FE0E86; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"396757\n"); - end - x = 64'h0010000000000001; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"398771\n"); - end - x = 64'hC024ABDD47F0BA3B; - y = 64'hBFF0000000000001; - z = 64'h002000FFBFFFFFFF; - ans = 64'h4024ABDD47F0BA3C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"400785\n"); - end - x = 64'hB7F9E772425B7128; - y = 64'hBFAFFDC000000000; - z = 64'h380FFFFFFFFBFFFD; - ans = 64'h381067967FEF4B19; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"402799\n"); - end - x = 64'h0010000000000001; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"404813\n"); - end - x = 64'hC7E000000000002F; - y = 64'hC010000000000001; - z = 64'hE8CFFFFFFF00007F; - ans = 64'hE8CFFFFFFF00007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"406827\n"); - end - x = 64'h42903FFFFFFFFFFE; - y = 64'h47E00000FEFFFFFF; - z = 64'hC03FFFFFFFFFEFF7; - ans = 64'h4A80400102FBFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"408841\n"); - end - x = 64'h0010000000000001; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"410855\n"); - end - x = 64'hBFD2000000FFFFFF; - y = 64'hFFE0000000000001; - z = 64'hC16FFFFFFFFF7FEF; - ans = 64'h7FC2000001000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"412869\n"); - end - x = 64'h34E0400000000002; - y = 64'hC071FFFE00000000; - z = 64'h47E0000000400200; - ans = 64'h47E0000000400200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"414883\n"); - end - x = 64'h0010000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"416897\n"); - end - x = 64'hB3DFFFFFFFEFFE00; - y = 64'h0000000000000000; - z = 64'h401BDB831CE041E3; - ans = 64'h401BDB831CE041E3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"418911\n"); - end - x = 64'h43E000000007FFFA; - y = 64'hBFB41FCB52017EB1; - z = 64'hBFC0919E9745A592; - ans = 64'hC3A41FCB520B8E8F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"420925\n"); - end - x = 64'h001FFFFFFFFFFFFF; - y = 64'h0010000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"422939\n"); - end - x = 64'hBC59DD57D7AE3685; - y = 64'h3CA0000000000000; - z = 64'h40002001FFFFFFFE; - ans = 64'h40002001FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"424953\n"); - end - x = 64'h7FE000000007FFBE; - y = 64'hF8EFFFFFF7BFFFFF; - z = 64'h4004A9F4D740C561; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"426967\n"); - end - x = 64'h001FFFFFFFFFFFFF; - y = 64'h3FD0000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"428981\n"); - end - x = 64'h7FF0000800020000; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h3FCF9886FD508BAC; - ans = 64'h7FF8000800020000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"430995\n"); - end - x = 64'h80047FFFFFFFFFFF; - y = 64'h3FF0000001008000; - z = 64'h3FB5BEBC9BBB5778; - ans = 64'h3FB5BEBC9BBB5778; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"433009\n"); - end - x = 64'h001FFFFFFFFFFFFF; - y = 64'h3FF0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"435023\n"); - end - x = 64'h40D000000000FFC0; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hBFF8001FFFFFFFFF; - ans = 64'h40DFFF9FFF81FF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"437037\n"); - end - x = 64'h42A0400000FFFFFF; - y = 64'h3FB0007FEFFFFFFE; - z = 64'hC09F800000000400; - ans = 64'h42604081EFC407FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"439051\n"); - end - x = 64'h001FFFFFFFFFFFFF; - y = 64'h4010000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"441065\n"); - end - x = 64'hB81FFFC000000020; - y = 64'h401FFFFFFFFFFFFE; - z = 64'h0019444730A7E4F3; - ans = 64'hB84FFFC00000001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"443079\n"); - end - x = 64'h402AA929B284BE76; - y = 64'hBFF0000004000010; - z = 64'h802FFFFFFFFFFEEF; - ans = 64'hC02AA929B92F08FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"445093\n"); - end - x = 64'h001FFFFFFFFFFFFF; - y = 64'h7FE0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h4014000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"447107\n"); - end - x = 64'hC01FF00000000080; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h38DFFFFF70000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"449121\n"); - end - x = 64'h47E0001FFFFFFDFF; - y = 64'hBA7FFF007FFFFFFF; - z = 64'h3F1FC3FFFFFFFFFE; - ans = 64'hC26FFF407E00FBFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"451135\n"); - end - x = 64'h001FFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"453149\n"); - end - x = 64'h4F70000000040001; + x = 64'h47EC1A9C03D9ECB8; y = 64'h800FFFFFFFFFFFFF; - z = 64'h1FCFFFFE00FFFFFF; - ans = 64'h1FCFFFFE00FFFFFF; + z = 64'hBEDFFFFFFF7DFFFF; + ans = 64'hBEDFFFFFFF7DFFFF; rn = 1; rz = 0; rm = 0; @@ -10659,12 +2857,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"455163\n"); + $fwrite(fp,"36839\n"); end - x = 64'hC09000FFFFFBFFFE; - y = 64'h4020000FFFFFFFEE; - z = 64'h3FD0803FFFFFFFFF; - ans = 64'hC0C000EF007BFFE8; + x = 64'h0000000000000000; + y = 64'h7FF00000FFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h7FF80000FFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -10706,12 +2904,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"457177\n"); + $fwrite(fp,"37453\n"); end - x = 64'h001FFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + x = 64'hBFCFFFFFFFFFF002; + y = 64'hC6700000003BFFFE; + z = 64'hBFFFDFFFDFFFFFFF; + ans = 64'h46500000003BF7FF; rn = 1; rz = 0; rm = 0; @@ -10753,12 +2951,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"459191\n"); + $fwrite(fp,"38067\n"); end - x = 64'hC0300000020000FF; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hC1C00000020003FF; - ans = 64'hC1C00000020003FF; + x = 64'h0000000000000000; + y = 64'h8010000000000000; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -10800,12 +2998,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"461205\n"); + $fwrite(fp,"38681\n"); end - x = 64'h4031B1054AFF739B; - y = 64'hFFD0000080000004; - z = 64'hBFE000010FFFFFFE; - ans = 64'hFFF0000000000000; + x = 64'hB7F000008000001F; + y = 64'h4023FFFC00000000; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hB823FFFC9FFFE027; rn = 1; rz = 0; rm = 0; @@ -10847,3114 +3045,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"463219\n"); + $fwrite(fp,"39295\n"); end - x = 64'h001FFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"465233\n"); - end - x = 64'h49F200000000FFFF; - y = 64'hBFE0000000000001; - z = 64'hAEF0007FFFFFFFDF; - ans = 64'hC9E2000000010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"467247\n"); - end - x = 64'h3D9AAC08F7E44873; - y = 64'h2DC07FFFFF800000; - z = 64'hC36FFFFFFF800000; - ans = 64'hC36FFFFFFF800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"469261\n"); - end - x = 64'h001FFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"471275\n"); - end - x = 64'h3FBF8000001FFFFE; - y = 64'hC000000000000001; - z = 64'h37E00000007FEFFE; - ans = 64'hBFCF800000200000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"473289\n"); - end - x = 64'h8020007FFDFFFFFF; - y = 64'h9BEFFFF7FFF7FFFE; - z = 64'h000FFFFFFFF7FFFE; - ans = 64'h000FFFFFFFF7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"475303\n"); - end - x = 64'h001FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"477317\n"); - end - x = 64'hBA00000000047FFF; - y = 64'hC340000000000000; - z = 64'hC08020000000001F; - ans = 64'hC08020000000001D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"479331\n"); - end - x = 64'h3FF0100FFFFFFFFE; - y = 64'hFD2F1CCF1749CC84; - z = 64'hBFF7FFFFFFFFFFFD; - ans = 64'hFD2F3C0B03302D96; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"481345\n"); - end - x = 64'h001FFFFFFFFFFFFF; - y = 64'hFFE0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"483359\n"); - end - x = 64'h001BE8CBEEBEC207; - y = 64'hFFF0000000000000; - z = 64'hB7FEFFFBFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"485373\n"); - end - x = 64'hC7E00000003FEFFF; - y = 64'hBB542AAFA393CD33; - z = 64'hBCE007FFFFFFEFFF; - ans = 64'h43442AAFA3E463C6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"487387\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'h0000000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"489401\n"); - end - x = 64'h729F7FFFFFFFFFF0; - y = 64'h0010000000000000; - z = 64'h43F40FFFFFFFFFFF; - ans = 64'h43F40FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"491415\n"); - end - x = 64'h412FF7FFFFFFEFFE; - y = 64'h3FD785891B76C59A; - z = 64'h3A200007FFFF7FFF; - ans = 64'h41177FA7B92FDC24; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"493429\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'h3CA0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"495443\n"); - end - x = 64'h660000000010003F; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h40F80003FFFFFFFF; - ans = 64'h62C000000010003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"497457\n"); - end - x = 64'h49CFFF8007FFFFFF; - y = 64'hC7F09FFFFFFFFFFF; - z = 64'h3F1FFFFFFBFFFE00; - ans = 64'hD1D09FBD8427FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"499471\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'h3FE0000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"501485\n"); - end - x = 64'h3F4000100000003F; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h422FF00000007FFF; - ans = 64'h422FF0000000803F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"503499\n"); - end - x = 64'h48700001FBFFFFFE; - y = 64'hBFCFFFFFFC000400; - z = 64'hC05BFFFFFFFFFBFE; - ans = 64'hC8500001FA0001BF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"505513\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'h4000000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"507527\n"); - end - x = 64'h41C00000001003FF; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h3CA7FFFBFFFFFFFF; - ans = 64'h41E00000001003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"509541\n"); - end - x = 64'h41D0000000080200; - y = 64'hE53FFFF7FFFFFFE0; - z = 64'h44E00000401FFFFE; - ans = 64'hE71FFFF8001003DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"511555\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'h4340000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"513569\n"); - end - x = 64'hC340000000007F7F; - y = 64'h434FFFFFFFFFFFFF; - z = 64'hBFEFFFFFFFEFFFFA; - ans = 64'hC6A0000000007F7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"515583\n"); - end - x = 64'h37A0000020007FFF; - y = 64'h800FF7FFFDFFFFFF; - z = 64'hBF1FFFFA00000000; - ans = 64'hBF1FFFFA00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"517597\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'h401BFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"519611\n"); - end - x = 64'hB937F8E1E5E7C624; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hC0207FFFFFFFFFFC; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"521625\n"); - end - x = 64'hC012751F6F8812B9; - y = 64'h41D0000000003FFE; - z = 64'h7FFFFFFBFFFFFFEE; - ans = 64'h7FFFFFFBFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"523639\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"525653\n"); - end - x = 64'h31F000000000FFEE; - y = 64'h8010000000000001; - z = 64'hBFC0001FFFFFFFBF; - ans = 64'hBFC0001FFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"527667\n"); - end - x = 64'h4713EE08A1624B47; - y = 64'h42DDFFFE00000000; - z = 64'h47F1FFFFFFFFFFEE; - ans = 64'h4A02AF26D8749C7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"529681\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"531695\n"); - end - x = 64'hBCA010001FFFFFFE; - y = 64'hBFD0000000000001; - z = 64'h480FFE000000000F; - ans = 64'h480FFE000000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"533709\n"); - end - x = 64'h3ED03FEFFFFFFFFE; - y = 64'hBF1FFBFFF7FFFFFE; - z = 64'h3FD000000000037E; - ans = 64'h3FCFFFFFFEFC287C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"535723\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"537737\n"); - end - x = 64'h3FBF800000001000; - y = 64'hBFF0000000000001; - z = 64'hC1DFFFFF7FFF7FFF; - ans = 64'hC1DFFFFF80075FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"539751\n"); - end - x = 64'hC02C219606615D02; - y = 64'h40D0000001FDFFFE; - z = 64'hBFB0002800000000; - ans = 64'hC10C219689E34B8D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"541765\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"543779\n"); - end - x = 64'hC0000000007FFFF6; - y = 64'hC010000000000000; - z = 64'hC04FFFFFEFFFFFFF; - ans = 64'hC04BFFFFEFE00002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"545793\n"); - end - x = 64'h3000000000060000; - y = 64'h8027427682235497; - z = 64'hC0EFFFC000FFFFFF; - ans = 64'hC0EFFFC000FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"547807\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'hC340000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"549821\n"); - end - x = 64'hC34FFFFFFF0000FF; - y = 64'hFFE0000000000000; - z = 64'h3FE00AB9CB1DBB7F; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"551835\n"); - end - x = 64'h401FFFBFFFFFFFFC; - y = 64'hC0000000000100FF; - z = 64'h3FDB0C7F1AA6DCB7; - ans = 64'hC02F275C072CCB10; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"553849\n"); - end - x = 64'h001FFFFFFFFFFFFE; - y = 64'hFFF0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"555863\n"); - end - x = 64'h3F9FE007FFFFFFFF; - y = 64'h0000000000000000; - z = 64'h420FFFFFE0000800; - ans = 64'h420FFFFFE0000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"557877\n"); - end - x = 64'h3FE2D582A960D8AF; - y = 64'hBC0FF8FEBC1E5412; - z = 64'hC310000401FFFFFF; - ans = 64'hC310000401FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"559891\n"); - end - x = 64'h3CA0000000000000; - y = 64'h0010000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"561905\n"); - end - x = 64'hBDA000000001FF7F; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h41C0003FFFFFFFFE; - ans = 64'h41C0003FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"563919\n"); - end - x = 64'hBFE001C000000000; - y = 64'hC3D00000FFBFFFFE; - z = 64'h8001000007FFFFFE; - ans = 64'h43C001C0FFDBF8FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"565933\n"); - end - x = 64'h3CA0000000000000; - y = 64'h3FD0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"567947\n"); - end - x = 64'hC1D14111A4841268; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h480100000003FFFE; - ans = 64'h480100000003FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"569961\n"); - end - x = 64'h409FF7FFFFFFF7FF; - y = 64'hBF836AC78348EB47; - z = 64'hBFC2000007FFFFFF; - ans = 64'hC03389ECD1781431; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"571975\n"); - end - x = 64'h3CA0000000000000; - y = 64'h3FF0000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"573989\n"); - end - x = 64'h47E000004007FFFF; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h8016D5FA0A20E196; - ans = 64'h47F000004007FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"576003\n"); - end - x = 64'hC345DA03C17A0BF0; - y = 64'hEBAFE07FFFFFFFFF; - z = 64'h3E8FFFFFDC000000; - ans = 64'h6F05C48125C797CC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"578017\n"); - end - x = 64'h3CA0000000000000; - y = 64'h400FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"580031\n"); - end - x = 64'h3FD03FFFFFFFFFFC; - y = 64'h401FFFFFFFFFFFFF; - z = 64'hB9BFFFE100000000; - ans = 64'h40003FFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"582045\n"); - end - x = 64'h381FFFFFE01FFFFF; - y = 64'hC34FFFFF007FFFFF; - z = 64'hBFBBFFF7FFFFFFFF; - ans = 64'hBFBBFFF7FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"584059\n"); - end - x = 64'h3CA0000000000000; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"586073\n"); - end - x = 64'h411000FFF7FFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'hBFD1FFFC00000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"588087\n"); - end - x = 64'h3CA8C3076307D67C; - y = 64'h37FFFFFFFFFFFF5F; - z = 64'hFFFFFFFFE0000008; - ans = 64'hFFFFFFFFE0000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"590101\n"); - end - x = 64'h3CA0000000000000; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"592115\n"); - end - x = 64'hC1C0008007FFFFFF; - y = 64'h8000000000000001; - z = 64'hC6B4F3502E84A07B; - ans = 64'hC6B4F3502E84A07B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"594129\n"); - end - x = 64'hC1D45D281AA37A03; - y = 64'h3C80DFFFFFFFFFFF; - z = 64'h3FE080000000FFFE; - ans = 64'h3FE07FFFEA86BFB2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"596143\n"); - end - x = 64'h3CA0000000000000; + x = 64'h0000000000000000; y = 64'h801FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + z = 64'h380100000000003E; + ans = 64'h380100000000003E; rn = 1; rz = 0; rm = 0; @@ -13996,12 +3092,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"598157\n"); + $fwrite(fp,"39909\n"); end - x = 64'hC16C70639E2CF0BA; + x = 64'h3EF00000000004FF; + y = 64'hC35FFFBFFFFFFFEF; + z = 64'h800B04413DF080C3; + ans = 64'hC25FFFC0000009ED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"40523\n"); + end + x = 64'h407F00003FFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"41137\n"); + end + x = 64'h0000000000000000; + y = 64'h7FDFFFFFEFFFFF00; + z = 64'hB7F0000000021000; + ans = 64'hB7F0000000021000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"41751\n"); + end + x = 64'hBFDFF7FFFFF7FFFF; y = 64'hBCA0000000000001; - z = 64'h2100003FFFFFFFFB; - ans = 64'h3E1C70639E2CF0BC; + z = 64'hC7F82F3AAACD8D77; + ans = 64'hC7F82F3AAACD8D77; rn = 1; rz = 0; rm = 0; @@ -14043,12 +3280,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"600171\n"); + $fwrite(fp,"42365\n"); end - x = 64'hAE40000101FFFFFF; - y = 64'h47EFFFFF8007FFFF; - z = 64'h001D5692792CE747; - ans = 64'hB6400000C203FBF7; + x = 64'h0000000000000000; + y = 64'hC5B0004000000100; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -14090,12 +3327,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"602185\n"); + $fwrite(fp,"42979\n"); end - x = 64'h3CA0000000000000; + x = 64'hBFF000FF7FFFFFFF; + y = 64'h48BDFFFF7FFFFFFF; + z = 64'h3F671AAF77E7002B; + ans = 64'hC8BE01DE8FF803FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"43593\n"); + end + x = 64'h0000000000000000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"44207\n"); + end + x = 64'h800FFFFF807FFFFF; + y = 64'h43F0000000000005; + z = 64'h8000000000000000; + ans = 64'h840FFFFF01000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"44821\n"); + end + x = 64'h0000000000000000; + y = 64'hBFD0000000000001; + z = 64'hECAFFFFFF7FFFFEE; + ans = 64'hECAFFFFFF7FFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"45435\n"); + end + x = 64'h6010000000007DFF; + y = 64'h3E93A970CD45CF6F; + z = 64'h480391CF914CBF65; + ans = 64'h5EB3A970CD466A44; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"46049\n"); + end + x = 64'hC02FFFFFFCFFFFFF; y = 64'hBFDFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC010000000000000; + ans = 64'h400FFFFFF9FFFFFC; rn = 1; rz = 0; rm = 0; @@ -14137,12 +3609,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"604199\n"); + $fwrite(fp,"46663\n"); end - x = 64'h0020000000800100; - y = 64'hBFE0000000000001; - z = 64'h3F0FFFFF80FFFFFE; - ans = 64'h3F0FFFFF80FFFFFE; + x = 64'h0000000000000000; + y = 64'h3999E763325E2F3C; + z = 64'hC04495126EB489F2; + ans = 64'hC04495126EB489F2; rn = 1; rz = 0; rm = 0; @@ -14184,12 +3656,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"606213\n"); + $fwrite(fp,"47277\n"); end - x = 64'h41E27AFC7F681471; - y = 64'hC1900000017FFFFF; - z = 64'hBFDFFFFFFC000007; - ans = 64'hC3827AFC81239C1C; + x = 64'h3EB000040003FFFF; + y = 64'hBFE0000000000000; + z = 64'h34D7185B3B3DEA47; + ans = 64'hBEA000040003FFFF; rn = 1; rz = 0; rm = 0; @@ -14231,11 +3703,1703 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"608227\n"); + $fwrite(fp,"47891\n"); end - x = 64'h3CA0000000000000; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; + x = 64'h0000000000000000; + y = 64'hC06FFFFFF7FFDFFF; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"48505\n"); + end + x = 64'h3FEFFFFF7FFFFFFD; + y = 64'h3B7FFC0001FFFFFE; + z = 64'h7FD000000200001F; + ans = 64'h7FD000000200001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"49119\n"); + end + x = 64'h0000000000000000; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"49733\n"); + end + x = 64'hBE0FFDFFFFDFFFFF; + y = 64'h3F8FFFF80007FFFF; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"50347\n"); + end + x = 64'h0000000000000000; + y = 64'hBFF0000000000000; + z = 64'h3FB0000000000801; + ans = 64'h3FB0000000000801; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"50961\n"); + end + x = 64'h40FC000FFFFFFFFF; + y = 64'hC7EFFFBFFFFFF7FF; + z = 64'h3D4FFFFFFFFF87FF; + ans = 64'hC8FBFFD7FFDFF8FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"51575\n"); + end + x = 64'hC1E000000005FFFF; + y = 64'hBFF0000000000001; + z = 64'hC000000000000001; + ans = 64'h41DFFFFFFF8C0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"52189\n"); + end + x = 64'h0000000000000000; + y = 64'h380C1CB161614663; + z = 64'hC051FFFFFFFF7FFF; + ans = 64'hC051FFFFFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"52803\n"); + end + x = 64'hB9A00000007FFDFE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hC1D80003FFFFFFFF; + ans = 64'hC1D80003FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"53417\n"); + end + x = 64'h0000000000000000; + y = 64'h434FF0000003FFFE; + z = 64'h3CA0000000000001; + ans = 64'h3CA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"54031\n"); + end + x = 64'hB9C000000400001F; + y = 64'hC01FFFFEFC000000; + z = 64'hC1D00007FFFFFBFF; + ans = 64'hC1D00007FFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"54645\n"); + end + x = 64'h0000000000000000; + y = 64'hC000000000000001; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"55259\n"); + end + x = 64'h414E31CF11CCD625; + y = 64'h4000000000000081; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"55873\n"); + end + x = 64'h0000000000000000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hFFD0000002FFFFFF; + ans = 64'hFFD0000002FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"56487\n"); + end + x = 64'h7FF0000000000040; + y = 64'hC00255D9EE601C85; + z = 64'h4026389D5E21B837; + ans = 64'h7FF8000000000040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"57101\n"); + end + x = 64'h41E0000003FFE000; + y = 64'hC010000000000000; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hC2000000040FE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"57715\n"); + end + x = 64'h0000000000000000; + y = 64'hC1F080000003FFFF; + z = 64'hBFCFFEFFEFFFFFFF; + ans = 64'hBFCFFEFFEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"58329\n"); + end + x = 64'hC1EE67D76FC4673E; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h4DF044E1B605B6E2; + ans = 64'h4DF044E1B605B6E2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"58943\n"); + end + x = 64'h0000000000000000; + y = 64'hBF9004000000000F; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h001FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"59557\n"); + end + x = 64'h43CF600000000000; + y = 64'hC7E000FFFFF80000; + z = 64'hC3F3F7FFFFFFFFFF; + ans = 64'hCBBF61F5FFF05000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"60171\n"); + end + x = 64'h0000000000000000; + y = 64'hC340000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"60785\n"); + end + x = 64'h49F0000000000077; + y = 64'hBFE0000000000800; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'hC9E0000000000877; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"61399\n"); + end + x = 64'h0000000000000000; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC7EFFFC000003FFF; + ans = 64'hC7EFFFC000003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"62013\n"); + end + x = 64'h3FE0008FFFFFFFFF; + y = 64'h400B829FD71AD041; + z = 64'h3E4F6B8CA9EEBB1D; + ans = 64'h3FFB839772A6D1C6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"62627\n"); + end + x = 64'h41E008001FFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hC54008001FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"63241\n"); + end + x = 64'h0000000000000000; + y = 64'hBF70000010000020; + z = 64'hBF18000200000000; + ans = 64'hBF18000200000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"63855\n"); + end + x = 64'h6F4FFFF7FFFFF7FE; + y = 64'hFFE0000000000001; + z = 64'h3E4FFFFFFFFFFFF3; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"64469\n"); + end + x = 64'h0000000000000000; + y = 64'h3FEFE000000007FF; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h000FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"65083\n"); + end + x = 64'hB42007FFFFFF7FFF; + y = 64'h3FF0001FFFFFFFFE; + z = 64'hC3FFFFFFFFF87FFE; + ans = 64'hC3FFFFFFFFF87FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"65697\n"); + end + x = 64'h0000000000000000; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h801FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"66311\n"); + end + x = 64'h406FFFFFFFDF0000; + y = 64'h3EF003FFFFFFFFFA; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"66925\n"); + end + x = 64'h0000000000000000; + y = 64'hFFF0000000000001; + z = 64'h3FA0000EFFFFFFFE; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"67539\n"); + end + x = 64'h407FFDFFEFFFFFFE; + y = 64'hBBAFFFBFFFFFBFFE; + z = 64'h4300000400000FFF; + ans = 64'h4300000400000FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"68153\n"); + end + x = 64'h4014000FFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hBFE0000000000000; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"68767\n"); + end + x = 64'h0000000000000000; + y = 64'h8000200000000FFF; + z = 64'h480FF800000007FE; + ans = 64'h480FF800000007FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"69381\n"); + end + x = 64'h3CA4F5D8A9F2E2BD; + y = 64'h0000000000000000; + z = 64'h3F0C0001FFFFFFFF; + ans = 64'h3F0C0001FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"69995\n"); + end + x = 64'h0000000000000001; + y = 64'h37FFFFFFBFFF7FFF; + z = 64'h0000000000000000; ans = 64'h0000000000000000; rn = 1; rz = 0; @@ -14278,12 +5442,4054 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"610241\n"); + $fwrite(fp,"70609\n"); end - x = 64'hBFD0000120000000; + x = 64'hBFB0027907AD9078; + y = 64'h46901000000001FE; + z = 64'hC3E91A11BDC49CCC; + ans = 64'hC650127B80B5723B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"71223\n"); + end + x = 64'h0000000000000001; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h8010000000000000; + ans = 64'h8010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"71837\n"); + end + x = 64'hB800000007FFF7FF; + y = 64'h400FFFFDFFFFFF00; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"72451\n"); + end + x = 64'h0000000000000001; + y = 64'h0010000000000000; + z = 64'hE20A6BB7018E117C; + ans = 64'hE20A6BB7018E117C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"73065\n"); + end + x = 64'hB87FFFFF8FFFFFFE; + y = 64'h3FC00001FFFFDFFF; + z = 64'hC7E0007FFFFFFFEF; + ans = 64'hC7E0007FFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"73679\n"); + end + x = 64'hC3D000000000FBFF; + y = 64'h0010000000000001; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"74293\n"); + end + x = 64'h0000000000000001; + y = 64'h801FFFFFFE00000E; + z = 64'hFFD000000FDFFFFF; + ans = 64'hFFD000000FDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"74907\n"); + end + x = 64'h2B4FFEFFFFFFBFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h41EFFFFFEFFFFFFE; + ans = 64'h41EFFFFFEFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"75521\n"); + end + x = 64'h0000000000000001; + y = 64'hC0886A6D27B660AD; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"76135\n"); + end + x = 64'hBEC00000004000FF; + y = 64'hFFFFFE00000000FF; + z = 64'h404C9C600D9E0B67; + ans = 64'hFFFFFE00000000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"76749\n"); + end + x = 64'h0000000000000001; + y = 64'h3CA0000000000001; + z = 64'h8000000000000001; + ans = 64'h8000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"77363\n"); + end + x = 64'h3FF000043FFFFFFF; + y = 64'hC04254549FAA7BB9; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'hC04054597E10F621; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"77977\n"); + end + x = 64'h0000000000000001; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hBFD0000000004200; + ans = 64'hBFD0000000004200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"78591\n"); + end + x = 64'hC1C0000FFDFFFFFF; + y = 64'hE9100000027FFFFF; + z = 64'h350FBFFFC0000000; + ans = 64'h6AE000100080027E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"79205\n"); + end + x = 64'hFFF07FFFFFFFFFFB; + y = 64'h3FD0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hFFF87FFFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"79819\n"); + end + x = 64'h0000000000000001; + y = 64'hC030000000003F00; + z = 64'hFFE1B726A50BCA05; + ans = 64'hFFE1B726A50BCA05; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"80433\n"); + end + x = 64'hC80FFFFF83FFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hB7FFFFFF7FFFFFFE; + ans = 64'hC7FFFFFF83FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"81047\n"); + end + x = 64'h0000000000000001; + y = 64'h833DFFF7FFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"81661\n"); + end + x = 64'hBFC17DF54982AC71; + y = 64'h3A1F000008000000; + z = 64'h37E1000000000FFF; + ans = 64'hB9F0F205A38D9460; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"82275\n"); + end + x = 64'h0000000000000001; + y = 64'h3FE0000000000000; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"82889\n"); + end + x = 64'hC80FFFFFEFFFFFDF; + y = 64'hAE2FE00007FFFFFE; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"83503\n"); + end + x = 64'h0000000000000001; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3F39D2473C5B08B5; + ans = 64'h3F39D2473C5B08B5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"84117\n"); + end + x = 64'hB1CFEDFFFFFFFFFF; + y = 64'hFFF000077FFFFFFF; + z = 64'h8020000000200002; + ans = 64'hFFF800077FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"84731\n"); + end + x = 64'h3E280000000FFFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h3E280000000FFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"85345\n"); + end + x = 64'h0000000000000001; + y = 64'h7FDFFFFEFFFFFFBF; + z = 64'h4000000000080004; + ans = 64'h4000000000080005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"85959\n"); + end + x = 64'h40200008001FFFFE; + y = 64'h3FF0000000000001; + z = 64'h3F6FFFFFFEFFFF7F; + ans = 64'h40200208001FEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"86573\n"); + end + x = 64'h0000000000000001; + y = 64'h37EFFC0000000000; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"87187\n"); + end + x = 64'hFFF91C3BFB37550F; + y = 64'hBFE000020000007F; + z = 64'h402BFFFFF8000000; + ans = 64'hFFF91C3BFB37550F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"87801\n"); + end + x = 64'h0000000000000001; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"88415\n"); + end + x = 64'hC01B2E4B33B41899; + y = 64'hBDE0CE2A5F517DF6; + z = 64'h3FF0000000000000; + ans = 64'h3FF000000039190E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"89029\n"); + end + x = 64'h0000000000000001; + y = 64'h4000000000000001; + z = 64'hC3FFFFFFFFFF8006; + ans = 64'hC3FFFFFFFFFF8006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"89643\n"); + end + x = 64'hFFD007FFFFFFFC00; + y = 64'hBCAD04958D1CA9A2; + z = 64'h3FC7FFFFFFFDFFFF; + ans = 64'h7C8D1317D7E330B6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"90257\n"); + end + x = 64'hE3F5D3ABA7E0799B; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h8010000000000000; + ans = 64'hE415D3ABA7E0799A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"90871\n"); + end + x = 64'h0000000000000001; + y = 64'hC3DED4D0B02CD6AA; + z = 64'h000C158AC12AC439; + ans = 64'h80BED1CB4D7C8BF9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"91485\n"); + end + x = 64'h4F80041000000000; + y = 64'h4010000000000000; + z = 64'hB9F7BA96E673F02C; + ans = 64'h4FA0041000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"92099\n"); + end + x = 64'h0000000000000001; + y = 64'hC00FFFFFFFFFF807; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"92713\n"); + end + x = 64'hB3DC67A3FC46B7D8; + y = 64'hC1CBE5E7797B2F35; + z = 64'h76AFC0000FFFFFFF; + ans = 64'h76AFC0000FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"93327\n"); + end + x = 64'h0000000000000001; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"93941\n"); + end + x = 64'hC3DFFFEDFFFFFFFF; + y = 64'h3FD0001FFFFFEFFF; + z = 64'h3FE0000000000001; + ans = 64'hC3C00016FFEDEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"94555\n"); + end + x = 64'h0000000000000001; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h4340000023FFFFFF; + ans = 64'h4340000023FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"95169\n"); + end + x = 64'h40FFFDFF7FFFFFFF; + y = 64'hC34FFDFFFFFFFFEF; + z = 64'h7E0FFEFFFFEFFFFF; + ans = 64'h7E0FFEFFFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"95783\n"); + end + x = 64'hC1DFFFFFFFFFFF7E; + y = 64'h4340000000000001; + z = 64'h8000000000000001; + ans = 64'hC52FFFFFFFFFFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"96397\n"); + end + x = 64'h0000000000000001; + y = 64'h3FF00003FFFEFFFF; + z = 64'hFFEFF000000001FF; + ans = 64'hFFEFF000000001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"97011\n"); + end + x = 64'hC15000000010001F; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h47F55792228596A0; + ans = 64'h47F557922285969F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"97625\n"); + end + x = 64'h0000000000000001; + y = 64'hBFAAABC3854D8AAA; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"98239\n"); + end + x = 64'hB7E01FFFFFFFF800; + y = 64'hC7F2000000000003; + z = 64'hBFEF7FFEFFFFFFFF; + ans = 64'hBFDAB7FE000011F8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"98853\n"); + end + x = 64'h0000000000000001; + y = 64'h7FE0000000000001; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"99467\n"); + end + x = 64'hFFFFE0000000000E; + y = 64'hBCB0FFFFFFF7FFFF; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'hFFFFE0000000000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"100081\n"); + end + x = 64'h0000000000000001; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h43C0000000FFFFFB; + ans = 64'h43C0000000FFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"100695\n"); + end + x = 64'h46C5E1DB918AAA60; + y = 64'hC05FF77FFFFFFFFF; + z = 64'h3EEE3AB867132DBF; + ans = 64'hC735DC0B9338018A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"101309\n"); + end + x = 64'hC3EF7FF7FFFFFFFF; + y = 64'h7FF0000000000000; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"101923\n"); + end + x = 64'h0000000000000001; + y = 64'hFDD0000010000FFE; + z = 64'hC95336CB2C26A80E; + ans = 64'hC95336CB2C26A80E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"102537\n"); + end + x = 64'hC121216432DE4B7B; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h3FBE000000003FFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"103151\n"); + end + x = 64'h0000000000000001; + y = 64'h4446AF233378CEC0; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"103765\n"); + end + x = 64'h4050020000000100; + y = 64'h40F64E3F0BD07E03; + z = 64'h41E07FFFFFFFFFBF; + ans = 64'h41E08B288469D8BC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"104379\n"); + end + x = 64'h0000000000000001; + y = 64'h8000000000000000; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"104993\n"); + end + x = 64'h47EE78ADB65F42F6; + y = 64'h8638A91112ECACCA; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"105607\n"); + end + x = 64'h0000000000000001; + y = 64'h8000000000000001; + z = 64'h41F0010FFFFFFFFF; + ans = 64'h41F0010FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"106221\n"); + end + x = 64'h3FD43D5700152CCF; + y = 64'h40DA29B21651007D; + z = 64'h3420000004003FFE; + ans = 64'h40C08C35EADAA763; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"106835\n"); + end + x = 64'h3FEFFFFFFFFFF0FF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"107449\n"); + end + x = 64'h0000000000000001; + y = 64'hB81FFFC0007FFFFE; + z = 64'hC1C00000017FFFFF; + ans = 64'hC1C00000017FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"108063\n"); + end + x = 64'hBF8174D88196FAA3; + y = 64'h8010000000000000; + z = 64'h381FFFFFEFFFFFFF; + ans = 64'h381FFFFFEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"108677\n"); + end + x = 64'h0000000000000001; + y = 64'h4010000003FFEFFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"109291\n"); + end + x = 64'hEB2F000000000000; + y = 64'hA174D8D7ABF83504; + z = 64'hC2D90E3B93B7E7E0; + ans = 64'h4CB43210EE98735C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"109905\n"); + end + x = 64'h0000000000000001; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"110519\n"); + end + x = 64'hC1F367DA2CF3586B; + y = 64'hC1DF800000007FFF; + z = 64'h3CA0000000000000; + ans = 64'h43E31A3AC43FD8A8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"111133\n"); + end + x = 64'h0000000000000001; + y = 64'hBCA0000000000000; + z = 64'h3FDF5FE30D19D2F1; + ans = 64'h3FDF5FE30D19D2F1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"111747\n"); + end + x = 64'hC85F87FFFFFFFFFF; + y = 64'h45188A3DBE3CCC18; + z = 64'h3E6FFFFFFF01FFFF; + ans = 64'hCD882E3756B3681A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"112361\n"); + end + x = 64'h41E00000FFBFFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"112975\n"); + end + x = 64'h0000000000000001; + y = 64'h40001FFFFDFFFFFE; + z = 64'hC05FFFFFFF8007FF; + ans = 64'hC05FFFFFFF8007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"113589\n"); + end + x = 64'hC7F00000FFFFFBFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h38000000002007FE; + ans = 64'h44B00000FFFFFBFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"114203\n"); + end + x = 64'h0000000000000001; + y = 64'h404FFF7F7FFFFFFF; + z = 64'hBFF0000000000000; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"114817\n"); + end + x = 64'h3FF0000000040001; + y = 64'h381DCC6F8DD95714; + z = 64'hBFDE91054BF087B4; + ans = 64'hBFDE91054BF087B4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"115431\n"); + end + x = 64'h0000000000000001; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"116045\n"); + end + x = 64'h55BA9A28FB6E818D; + y = 64'hC91FFFC000000200; + z = 64'h0010000000000001; + ans = 64'hDEEA99F3C71C8C5A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"116659\n"); + end + x = 64'h0000000000000001; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFBFC0; + ans = 64'h801FFFFFFFFFBFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"117273\n"); + end + x = 64'h41D0000008003FFE; + y = 64'h38100000FFF7FFFF; + z = 64'h3CAFFFFBFFF80000; + ans = 64'h3CAFFFFBFFF80200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"117887\n"); + end + x = 64'hC1F010000000000F; + y = 64'hBFE0000000000001; + z = 64'h4340000000000001; + ans = 64'h4340000040400001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"118501\n"); + end + x = 64'h0000000000000001; + y = 64'h3FB9B590EB570621; + z = 64'hC00FFFC00001FFFE; + ans = 64'hC00FFFC00001FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"119115\n"); + end + x = 64'h4220000000403FFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h3FF000200000003F; + ans = 64'hC2200000003E3FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"119729\n"); + end + x = 64'h0000000000000001; + y = 64'h401003FFFFFFFF7F; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"120343\n"); + end + x = 64'h2890000100003FFF; + y = 64'hB83F246C2E31EA5B; + z = 64'h0D4001FFFFFFFFE0; + ans = 64'hA0DF246E207929CE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"120957\n"); + end + x = 64'h0000000000000001; + y = 64'hBFF0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"121571\n"); + end + x = 64'h3F0C00FFFFFFFFFF; + y = 64'hC7FFE0000000001F; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hC71BE4FF0000001A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"122185\n"); + end + x = 64'h0000000000000001; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hBF9000000001FFF0; + ans = 64'hBF9000000001FFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"122799\n"); + end + x = 64'h3FE0013FFFFFFFFF; + y = 64'hC1DF7FFFE0000000; + z = 64'hBBEE000000000001; + ans = 64'hC1CF8275DFFD7FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"123413\n"); + end + x = 64'hBE900000E0000000; y = 64'hC000000000000000; - z = 64'h3FC00003FF7FFFFF; - ans = 64'h3FE400021FE00000; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h40200000100000E0; rn = 1; rz = 0; rm = 0; @@ -14325,12 +9531,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"612255\n"); + $fwrite(fp,"124027\n"); end - x = 64'h428821EC16CB5777; - y = 64'hA0DFFF7FFFFFFBFE; - z = 64'h402E008000000000; - ans = 64'h402E008000000000; + x = 64'h0000000000000001; + y = 64'h3FAFFBFFFFFFFDFF; + z = 64'hBFF0000000010800; + ans = 64'hBFF0000000010800; rn = 1; rz = 0; rm = 0; @@ -14372,12 +9578,33241 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"614269\n"); + $fwrite(fp,"124641\n"); + end + x = 64'hBFAFFFFF000007FE; + y = 64'hC000000000000001; + z = 64'hA698FCFB6D85D749; + ans = 64'h3FBFFFFF00000800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"125255\n"); + end + x = 64'h0000000000000001; + y = 64'hBFE0003FBFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"125869\n"); + end + x = 64'hC0002000000001FE; + y = 64'h40144398EEDB1AB3; + z = 64'hA070000008000003; + ans = 64'hC0246C2020B8D36E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"126483\n"); + end + x = 64'h0000000000000001; + y = 64'hC010000000000000; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"127097\n"); + end + x = 64'h3816DC2B1E087754; + y = 64'h3F8FF807FFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"127711\n"); + end + x = 64'h0000000000000001; + y = 64'hC010000000000001; + z = 64'hC7E65A23395745B0; + ans = 64'hC7E65A23395745B0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"128325\n"); + end + x = 64'hBF7001FFFFFF7FFF; + y = 64'hC020000004000003; + z = 64'h3FC4ECED1B89DFEF; + ans = 64'h3FC8ED6D1C89DFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"128939\n"); + end + x = 64'h400FDFFFFFFFFFBE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'hC03BDFFFFFFFFFBC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"129553\n"); + end + x = 64'h0000000000000001; + y = 64'h41D0FC9ED7065B94; + z = 64'h3CAFEFFFFFFF0000; + ans = 64'h3CAFEFFFFFFF0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"130167\n"); + end + x = 64'h43AFFFFFC0007FFE; + y = 64'hC340000000000000; + z = 64'h3FBFFFFBFFFFDFFE; + ans = 64'hC6FFFFFFC0007FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"130781\n"); + end + x = 64'h0000000000000001; + y = 64'h41CF7FFFFEFFFFFE; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"131395\n"); + end + x = 64'h43FFFFFFFFFFFFFE; + y = 64'hBFD0001FF7FFFFFE; + z = 64'h3F4007FFFFFFFFF7; + ans = 64'hC3E0001FF7FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"132009\n"); + end + x = 64'h0000000000000001; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"132623\n"); + end + x = 64'hB81FFFFFC000007F; + y = 64'h43DFFFFEFF7FFFFF; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"133237\n"); + end + x = 64'h0000000000000001; + y = 64'hFFE0000000000000; + z = 64'h40D4000040000000; + ans = 64'h40D4000040000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"133851\n"); + end + x = 64'h400AD4AEE5D49F38; + y = 64'hC1E8D952BE2C6406; + z = 64'h3FB11FFFFFFFFFFE; + ans = 64'hC204D5BACED9ABF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"134465\n"); + end + x = 64'hC3F21524BE4E3979; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h4000000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"135079\n"); + end + x = 64'h0000000000000001; + y = 64'hC34FFFFFFFFFFE00; + z = 64'hC00C0000000001FF; + ans = 64'hC00C0000000001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"135693\n"); + end + x = 64'hD17FFFFFFFFFFFF0; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h4010000000002FFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"136307\n"); + end + x = 64'h0000000000000001; + y = 64'h41D0FFFF00000000; + z = 64'hBCA0000000000000; + ans = 64'hBCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"136921\n"); + end + x = 64'h3FF000000000200F; + y = 64'h41CFFFFFFC000000; + z = 64'h3FF000002000000F; + ans = 64'h41CFFFFFFC80401F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"137535\n"); + end + x = 64'h0000000000000001; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h3FD0000000000000; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"138149\n"); + end + x = 64'h4341FFFFFFFFFEFF; + y = 64'hBF748BF93240CAB0; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"138763\n"); + end + x = 64'h0000000000000001; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hB8B000003F800000; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"139377\n"); + end + x = 64'hC17201583A2EF803; + y = 64'h40085B90C3F3027B; + z = 64'hBE4153CE82AFC214; + ans = 64'hC18B690EE5AD454B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"139991\n"); + end + x = 64'hC3E401FFFFFFFFFF; + y = 64'h0000000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"140605\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBFBFFDFFC0000000; + z = 64'h380000400FFFFFFE; + ans = 64'h380000400FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"141219\n"); + end + x = 64'h8E20000000000007; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h434FFFFFD7FFFFFF; + ans = 64'h434FFFFFD7FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"141833\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hB42F7FFFFFFFFE00; + z = 64'h8010000000000001; + ans = 64'h8010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"142447\n"); + end + x = 64'h4050000000002080; + y = 64'hC08FFFEFFFF00000; + z = 64'h4800200000000000; + ans = 64'h4800200000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"143061\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h0010000000000001; + z = 64'h3CA0000000000001; + ans = 64'h3CA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"143675\n"); + end + x = 64'h3FDFFFFFFFEFFFFD; + y = 64'hC1F0000005FFFFFF; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC35000002000000B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"144289\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h400000000003FE00; + ans = 64'h400000000003FE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"144903\n"); + end + x = 64'h405773C1B923E530; + y = 64'h3FD0512CFDE7267D; + z = 64'hBF87997BF553F060; + ans = 64'h4037E7CA80DC7473; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"145517\n"); + end + x = 64'hC1EFFFFFFF803FFE; + y = 64'h3CA0000000000000; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFF00000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"146131\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hC0AFFFFFFF80003F; + z = 64'hBACFFFFF7FFFEFFE; + ans = 64'hBACFFFFF7FFFEFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"146745\n"); + end + x = 64'h3FBFFDFFFFFFF800; + y = 64'h3CA0000000000001; + z = 64'h44AC4F8E8F747CBE; + ans = 64'h44AC4F8E8F747CBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"147359\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3FCFFC007FFFFFFF; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h800C007FEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"147973\n"); + end + x = 64'hC1C00008FFFFFFFF; + y = 64'h33E200000007FFFE; + z = 64'hFFA2FFFFFFFFFFFF; + ans = 64'hFFA2FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"148587\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3FD0000000000000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h0021FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"149201\n"); + end + x = 64'h3FEFFEFFFEFFFFFF; + y = 64'h3F1800000003FFFE; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFE800C000BA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"149815\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3FD0000000000001; + z = 64'h41FEFFFFFFFFFBFF; + ans = 64'h41FEFFFFFFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"150429\n"); + end + x = 64'h43F003FFFFE00000; + y = 64'h3FC03FFFFFFFBFFF; + z = 64'h3F100FFFFFFFFFFF; + ans = 64'h43C0440FFFDF3FEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"151043\n"); + end + x = 64'h80000FFFFFBFFFFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"151657\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3FF46233694EE7EA; + z = 64'hC1F00002000003FF; + ans = 64'hC1F00002000003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"152271\n"); + end + x = 64'h4F8FFFFFFFF9FFFF; + y = 64'h3FE0000000000000; + z = 64'h403DF104F345A123; + ans = 64'h4F7FFFFFFFF9FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"152885\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h4280008003FFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"153499\n"); + end + x = 64'hB77FFFBFFFFFFFF6; + y = 64'hAD73FFFFE0000000; + z = 64'h800702E5BA613332; + ans = 64'h2503FFD7E0003FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"154113\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h001FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"154727\n"); + end + x = 64'h7FE0000000021FFF; + y = 64'h3C5FFFFFDFFF0000; + z = 64'hC010000000000000; + ans = 64'h7C4FFFFFE0033FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"155341\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3FF0000000000000; + z = 64'hC3DFFBFFFFEFFFFF; + ans = 64'hC3DFFBFFFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"155955\n"); + end + x = 64'h002EDA7062F2B653; + y = 64'hBF48C2B69C3CC227; + z = 64'hC01FFFFFFFFFFF82; + ans = 64'hC01FFFFFFFFFFF82; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"156569\n"); + end + x = 64'h686FFFFFF8000200; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h3FD0000000000000; + ans = 64'h687FFFFFF80001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"157183\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBF4FFFFBFFFFFFFC; + z = 64'hBFF03E0000000000; + ans = 64'hBFF03E0000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"157797\n"); + end + x = 64'h38019EFBBA34957E; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h41F55F86DA17B5B8; + ans = 64'h41F55F86DA17B5B8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"158411\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3FF0000001000004; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"159025\n"); + end + x = 64'h40103FFFFFFFFFFD; + y = 64'h3FF000000001E000; + z = 64'h43C6885C3576B55B; + ans = 64'h43C6885C3576B55B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"159639\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h0000000000000000; + ans = 64'h002FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"160253\n"); + end + x = 64'hC3E0000000001010; + y = 64'h402FFFFBFF7FFFFF; + z = 64'hC000000000000001; + ans = 64'hC41FFFFBFF80201F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"160867\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hBF2EFFFFDFFFFFFF; + ans = 64'hBF2EFFFFDFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"161481\n"); + end + x = 64'hC06D269E93678E74; + y = 64'hC01FC2BEABDEFDBD; + z = 64'hC3C0001000FFFFFF; + ans = 64'hC3C0001000FFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"162095\n"); + end + x = 64'hF41FFFE00000007F; + y = 64'h4010000000000001; + z = 64'h3CA0000000000001; + ans = 64'hF43FFFE000000081; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"162709\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBFF057662D37995D; + z = 64'hC1CFFFFFFFFFFFC2; + ans = 64'hC1CFFFFFFFFFFFC2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"163323\n"); + end + x = 64'h3817B6E353940A3E; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3FAFFFFFFFF83FFF; + ans = 64'h3FAFFFFFFFF83FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"163937\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3BE001FFFFFFEFFF; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"164551\n"); + end + x = 64'hC0D00000403FFFFF; + y = 64'h80204CCA9259A411; + z = 64'h5B900000203FFFFF; + ans = 64'h5B900000203FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"165165\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h4340000000000000; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"165779\n"); + end + x = 64'h41C29C47332872B1; + y = 64'h381FFFFF81FFFFFF; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"166393\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hB7E7FFFFFFFDFFFF; + ans = 64'hB7E7FFFFFFFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"167007\n"); + end + x = 64'h3812BA3824E4D9E0; + y = 64'hC00FFFFFFFEFFFFE; + z = 64'h3F493F24CFFC16BF; + ans = 64'h3F493F24CFFC16BF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"167621\n"); + end + x = 64'hC1CFFFFFFFFFFF7F; + y = 64'h7FE0000000000000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"168235\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h7FFFFEFFFFFF8000; + z = 64'h43EFFFFF7FFFFFFE; + ans = 64'h7FFFFEFFFFFF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"168849\n"); + end + x = 64'hC3C523B80855F196; + y = 64'h7FE0000000000001; + z = 64'h400FFFEEFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"169463\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3D600FFF7FFFFFFF; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"170077\n"); + end + x = 64'h38B0000000041000; + y = 64'h41D0FAA3D73DCB12; + z = 64'h41FFFF7FBFFFFFFF; + ans = 64'h41FFFF7FBFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"170691\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"171305\n"); + end + x = 64'hC00FFFFFFF7FFDFF; + y = 64'h41DFEFF800000000; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hC1FFEFF7FF903E20; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"171919\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h7FF0000000000001; + z = 64'h7FE5A216D1F18F5C; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"172533\n"); + end + x = 64'hBF54477471BBE4DC; + y = 64'h4A3DFFFFFFFFFFFC; + z = 64'hC1DFFFFFE03FFFFF; + ans = 64'hC9A302FD2AA0268C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"173147\n"); + end + x = 64'h33EFFFFFEFFFBFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"173761\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBFDBFFFFFFEFFFFE; + z = 64'hC00FFFFFFC040000; + ans = 64'hC00FFFFFFC040000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"174375\n"); + end + x = 64'h3FBFFFFFF8000200; + y = 64'h8000000000000000; + z = 64'hB802E70A9756F601; + ans = 64'hB802E70A9756F601; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"174989\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBCD9BB552B097DCA; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"175603\n"); + end + x = 64'h3FFFFFE000FFFFFF; + y = 64'hBFBFFEFFFFFFFFFB; + z = 64'h380A0D5AA19EAA71; + ans = 64'hBFCFFEE001FFF7FA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"176217\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"176831\n"); + end + x = 64'hFFDC0000FFFFFFFF; + y = 64'hFDFFFFFFFFFFF801; + z = 64'hBFE0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"177445\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h8010000000000000; + z = 64'h402FFFFFFF800100; + ans = 64'h402FFFFFFF800100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"178059\n"); + end + x = 64'h3D900EFFFFFFFFFF; + y = 64'hC36C60E0A6FAA0B9; + z = 64'h251FC7AE5368B48E; + ans = 64'hC10C7B7B79972BAE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"178673\n"); + end + x = 64'h41FFEFFFFFFFFDFE; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h0000000000000000; + ans = 64'h822FEFFFFFFFFDFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"179287\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hC0E000000001FFFD; + z = 64'hC1CFFFFFF0007FFF; + ans = 64'hC1CFFFFFF0007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"179901\n"); + end + x = 64'hB7E0010000007FFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hDE4FFFDFFFFF7FFE; + ans = 64'hDE4FFFDFFFFF7FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"180515\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h43480AE532861422; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"181129\n"); + end + x = 64'h407EBFEA5ED3E8F1; + y = 64'h43DBEA5EAAF280D9; + z = 64'hC3C93A8974B023EF; + ans = 64'h446ACCD5778018ED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"181743\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBCA0000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"182357\n"); + end + x = 64'h48080001FFFFFFFE; + y = 64'h40E00000011FFFFF; + z = 64'hBFD0000000000001; + ans = 64'h48F8000201B00020; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"182971\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hB7F0E863BB89B480; + ans = 64'hB7F0E863BB89B480; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"183585\n"); + end + x = 64'h43D968AFF70E5E0C; + y = 64'h7D3000800000001F; + z = 64'hC3CDFFFFFFEFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"184199\n"); + end + x = 64'hC1AE5B70CEBC30DD; + y = 64'hBFD0000000000000; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"184813\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h40355F1CE077AB6A; + z = 64'h43F00000103FFFFF; + ans = 64'h43F00000103FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"185427\n"); + end + x = 64'h001FF80000100000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h394000000040001E; + ans = 64'h394000000040001E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"186041\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hC01F7FFFFFFFFFFE; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"186655\n"); + end + x = 64'hFFDFFFFFFFFBBFFF; + y = 64'h7FEF000000000200; + z = 64'h400FF8000007FFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"187269\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBFE0000000000000; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"187883\n"); + end + x = 64'hC1C00001FFFFFFF7; + y = 64'hC00E5D7AC1BB31DB; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h41DE5D7E8D6A8A01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"188497\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hC0AFF7FF00000000; + ans = 64'hC0AFF7FF00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"189111\n"); + end + x = 64'hB7F00000020003FF; + y = 64'h37F0000000077FFF; + z = 64'hC1F3DFFFFFFFFFFF; + ans = 64'hC1F3DFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"189725\n"); + end + x = 64'hB9F25F96065D1F51; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"190339\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hB7F8178C74E799A2; + z = 64'h3FB14A0681A30DCA; + ans = 64'h3FB14A0681A30DCA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"190953\n"); + end + x = 64'hB8002000000001FE; + y = 64'hBFF0000000000001; + z = 64'h400FFF800000000F; + ans = 64'h400FFF800000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"191567\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hB80E000000010000; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"192181\n"); + end + x = 64'hFFEF50983C19207E; + y = 64'hB9CA0738168F7A54; + z = 64'hBFF7C2C7A0B00686; + ans = 64'h79C9788C353FC999; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"192795\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"193409\n"); + end + x = 64'h3F1C000000FFFFFE; + y = 64'h3F5FF7FFFFFDFFFF; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h3E8BF90000FDFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"194023\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hC000000000000001; + z = 64'h3FB0000800000003; + ans = 64'h3FB0000800000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"194637\n"); + end + x = 64'hC3CFE00000007FFF; + y = 64'hC1D01000000FFFFF; + z = 64'h3FFFFFFEFFFFFFFF; + ans = 64'h45AFFFE00020607D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"195251\n"); + end + x = 64'h47EA12AFD077048D; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC80A12AFD077048C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"195865\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hC80C919352460A7E; + z = 64'h43C4A5E1CCDA6E01; + ans = 64'h43C4A5E1CCDA6E01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"196479\n"); + end + x = 64'h3F2CBAF78B0FA58F; + y = 64'hC010000000000000; + z = 64'h3CCD7C6CEDAF0060; + ans = 64'hBF4CBAF78B0F8813; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"197093\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBFBFFDF7FFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"197707\n"); + end + x = 64'h43D02FFFFFFFFFFE; + y = 64'h37F0000001FFFFFD; + z = 64'h3F9D452BB58B7274; + ans = 64'h3F9D452BB58B7274; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"198321\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"198935\n"); + end + x = 64'h41EFFFFFFFDFFFF0; + y = 64'h3F100000020001FE; + z = 64'h8010000000000000; + ans = 64'h4110000001F001F6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"199549\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hC340000000000000; + z = 64'hBFBFEFFBFFFFFFFF; + ans = 64'hBFBFEFFBFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"200163\n"); + end + x = 64'h3FEFFFFFFFFFFF83; + y = 64'hBFB005FFFFFFFFFE; + z = 64'h21E00000080003FE; + ans = 64'hBFB005FFFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"200777\n"); + end + x = 64'h491FFFFFFFFFBFFF; + y = 64'hC340000000000001; + z = 64'hC340000000000000; + ans = 64'hCC6FFFFFFFFFC001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"201391\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hC010000020000400; + z = 64'h400FFFFF807FFFFF; + ans = 64'h400FFFFF807FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"202005\n"); + end + x = 64'hC1CFFE07FFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h47A00000003DFFFF; + ans = 64'h47A00000003E1FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"202619\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h54200007FFFFE000; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"203233\n"); + end + x = 64'h4C2FFFFFFDFEFFFF; + y = 64'h480FFFFFFFF7E000; + z = 64'hC7E0000000FFFFF8; + ans = 64'h544FFFFFFDF6DFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"203847\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hFFE0000000000001; + z = 64'hBFF0000000000000; + ans = 64'hC008000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"204461\n"); + end + x = 64'h410E63FF6A5527C8; + y = 64'hB7E0B3FE678F16FD; + z = 64'h8000000000000001; + ans = 64'hB8FFB9E15BF4FE1E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"205075\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h000000000000007C; + ans = 64'hC00FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"205689\n"); + end + x = 64'h3FF0E30D389CC2AC; + y = 64'hC1FFFFFFEFFFFFFB; + z = 64'hA8D20000000003FF; + ans = 64'hC200E30D302B3C0D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"206303\n"); + end + x = 64'h480FFFFF7FFFFBFE; + y = 64'hFFF0000000000000; + z = 64'hC010000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"206917\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h413000007FFC0000; + z = 64'h7FFFFF8000000800; + ans = 64'h7FFFFF8000000800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"207531\n"); + end + x = 64'hC01FBFFFFFFFFFFC; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h7FEF7FFFFBFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"208145\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hC037A6B29B795033; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"208759\n"); + end + x = 64'h74501FFFE0000000; + y = 64'hFFDFF25176E4987F; + z = 64'h41F07FFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"209373\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h0000000000000000; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"209987\n"); + end + x = 64'hC3F0000001000002; + y = 64'h403FBFFFFFFFFFBF; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"210601\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hB81FFFFFFFFF0002; + ans = 64'hB81FFFFFFFFF0002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"211215\n"); + end + x = 64'h7FF9CDC93C37E5CE; + y = 64'h144BFFFF80000000; + z = 64'h3FE800000001FFFE; + ans = 64'h7FF9CDC93C37E5CE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"211829\n"); + end + x = 64'hC03F80000000000E; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"212443\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC3E02000FFFFFFFE; + z = 64'h4351FFFF00000000; + ans = 64'h4351FFFF00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"213057\n"); + end + x = 64'h3FEFF7FFFBFFFFFF; + y = 64'h0010000000000001; + z = 64'hC7EFFFFFFFEFDFFE; + ans = 64'hC7EFFFFFFFEFDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"213671\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h50464308CED89F99; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"214285\n"); + end + x = 64'h3C70000000FFF000; + y = 64'h3C6FFFFDF0000000; + z = 64'hC801BD5FB5B87EDD; + ans = 64'hC801BD5FB5B87EDD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"214899\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"215513\n"); + end + x = 64'hC03FFFEFFBFFFFFF; + y = 64'h403FF7EFFFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"216127\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3CA0000000000001; + z = 64'hBDAFF7EFFFFFFFFF; + ans = 64'hBDAFF7EFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"216741\n"); + end + x = 64'hB0700001FFDFFFFF; + y = 64'h47F0000000000010; + z = 64'hC0F824C774FC96AC; + ans = 64'hC0F824C774FC96AC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"217355\n"); + end + x = 64'h4C7FFFFC00004000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'h493FFFFC00003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"217969\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h4038FCF2DDB95CD2; + z = 64'h64F000000007FFF8; + ans = 64'h64F000000007FFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"218583\n"); + end + x = 64'h3E5E2E6A53E9291B; + y = 64'h3FD0000000000000; + z = 64'hC0ACC1E0EADB27EE; + ans = 64'hC0ACC1E0EADAEB91; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"219197\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h4EEFFFE000000020; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h0F0FFFE00000001C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"219811\n"); + end + x = 64'h40FBC1EF86378DB0; + y = 64'h3FD1000FFFFFFFFF; + z = 64'hBFB00BFFFFFFFFFE; + ans = 64'h40DD7E263D8A8CC1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"220425\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"221039\n"); + end + x = 64'h47F74CDAF7D04AC1; + y = 64'h3FBDFFFFFFFFFF80; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"221653\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3FE0000000000000; + z = 64'hC3C00007F8000000; + ans = 64'hC3C00007F8000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"222267\n"); + end + x = 64'h22FFFFFFFFFFBFFC; + y = 64'hFDA7FFFFC0000000; + z = 64'h3CAFFFFFFFFFE7FE; + ans = 64'hE0B7FFFFBFFFCFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"222881\n"); + end + x = 64'hD8D00000FFBFFFFF; + y = 64'h3FE0000000000001; + z = 64'hBFF0000000000000; + ans = 64'hD8C00000FFC00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"223495\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hBCAFFFFBFFFFFFF7; + z = 64'hC28FFFFFF0003FFF; + ans = 64'hC28FFFFFF0003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"224109\n"); + end + x = 64'h3FB2000000000400; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h47F7DD98F7C2DED1; + ans = 64'h47F7DD98F7C2DED1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"224723\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3FBFFDFFFFFFFFEF; + z = 64'h0010000000000000; + ans = 64'h0011FFDFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"225337\n"); + end + x = 64'hBFB0000000280000; + y = 64'h41803F7FFFFFFFFF; + z = 64'h802465A3B9118621; + ans = 64'hC1403F8000289EBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"225951\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3FF0000000000001; + z = 64'hBCA0000000000000; + ans = 64'hBCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"226565\n"); + end + x = 64'hBF8FFFE000020000; + y = 64'hC03FF000007FFFFF; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"227179\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC3D01F75DBA36D94; + ans = 64'hC3D01F75DBA36D94; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"227793\n"); + end + x = 64'hC80FFFFE000003FF; + y = 64'hAAC00000040001FF; + z = 64'h4AF74822E4CB078B; + ans = 64'h4AF74822E4CB078B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"228407\n"); + end + x = 64'hC6530B18D3D732F8; + y = 64'h4000000000000000; + z = 64'hBFE0000000000001; + ans = 64'hC6630B18D3D732F8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"229021\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h40D00000002FFFFE; + z = 64'hBF8FFFFF7EFFFFFE; + ans = 64'hBF8FFFFF7EFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"229635\n"); + end + x = 64'h2A1FFFFFFF7FFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h582FFFFFFFFFFC01; + ans = 64'h582FFFFFFFFFFC01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"230249\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h41DFFFFFFFFFF900; + z = 64'h0000000000000001; + ans = 64'h01FFFFFFFFFFF8FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"230863\n"); + end + x = 64'h416A5A4987DB72F7; + y = 64'hBFCFFFFFFF7FFFF7; + z = 64'h3F90040FFFFFFFFF; + ans = 64'hC14A5A49857187C9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"231477\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h4010000000000000; + z = 64'h8010000000000001; + ans = 64'h0027FFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"232091\n"); + end + x = 64'hC02C30BECB2AD454; + y = 64'hBFBFFFFFFFE00400; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h40238617D961D4E3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"232705\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h43E0000000040400; + ans = 64'h43E0000000040400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"233319\n"); + end + x = 64'h3FEFFFFFFFFF3FFF; + y = 64'h3FC89C5029E5BAE3; + z = 64'hBFFFFFFFFFFBFC00; + ans = 64'hBFFCEC75FABF5719; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"233933\n"); + end + x = 64'hBFF000000000004F; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hC02100000000004E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"234547\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3F0FFFFE7FFFFFFE; + z = 64'h3FEFF00007FFFFFF; + ans = 64'h3FEFF00007FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"235161\n"); + end + x = 64'h37FA13DD98EDB441; + y = 64'h4340000000000001; + z = 64'h81454CE0E2690CED; + ans = 64'h3B4A13DD98EDB443; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"235775\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h43EFFFFFFFFF801E; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"236389\n"); + end + x = 64'hC0007FFFFFFFBFFE; + y = 64'hBFDFFFFFFFFDFF80; + z = 64'hC2A2BD5FA60F3DDE; + ans = 64'hC2A2BD5FA60F3BCE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"237003\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h036FFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"237617\n"); + end + x = 64'h756FFFFFFC00003E; + y = 64'h3CF587D08EB672DD; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h727587D08C0578F5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"238231\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'hC00FFFFFC0000002; + ans = 64'hBFFFFFFF80000006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"238845\n"); + end + x = 64'h41F0000000008FFE; + y = 64'hB8000010FFFFFFFE; + z = 64'hBFFD9D819A979570; + ans = 64'hBFFD9D819A979570; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"239459\n"); + end + x = 64'h3111F5E51199ED7F; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'h7111F5E51199ED7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"240073\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC34E000000000200; + z = 64'h7FF0000000000C00; + ans = 64'h7FF8000000000C00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"240687\n"); + end + x = 64'h001000000200FFFF; + y = 64'h7FF0000000000000; + z = 64'h43D00FFFFFFFFFF7; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"241301\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC03C00000000003F; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"241915\n"); + end + x = 64'h3F8FFFFF7F7FFFFE; + y = 64'hB1BFFBFFFFFFFFC0; + z = 64'h3C9FFFBFFFFFFF7F; + ans = 64'h3C9FFFBFFFFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"242529\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"243143\n"); + end + x = 64'h402A5DF48F98AD36; + y = 64'h381FFFFFFEFFFFFD; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"243757\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h8000000000000000; + z = 64'hB33288221059078A; + ans = 64'hB33288221059078A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"244371\n"); + end + x = 64'h814931D84B67C1AA; + y = 64'h480FDFFFFFFC0000; + z = 64'h41F00FFFFDFFFFFF; + ans = 64'h41F00FFFFDFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"244985\n"); + end + x = 64'hC0F2D69C32093435; + y = 64'h8000000000000001; + z = 64'hBCA0000000000000; + ans = 64'hBCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"245599\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hBFDFFFFFF0200000; + z = 64'hC7FFD80000000000; + ans = 64'hC7FFD80000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"246213\n"); + end + x = 64'hB813FC0000000000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h7FDFFFFEC0000000; + ans = 64'h7FDFFFFEC0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"246827\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hBBD1FFFFFFFFFFFF; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"247441\n"); + end + x = 64'h41C180E153D6F2EC; + y = 64'hC03F020000000000; + z = 64'h3FE7DDEDE7BDA1DF; + ans = 64'hC210F5F2574A7D06; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"248055\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h8010000000000001; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"248669\n"); + end + x = 64'h380C4BA9646D43BB; + y = 64'hBE06F94240DDBEA5; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"249283\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hC021000000000000; + ans = 64'hC021000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"249897\n"); + end + x = 64'h3FD8B6FF3FCFD46E; + y = 64'h001FFFFFFFFFEFFF; + z = 64'hA97074FAD68B5F25; + ans = 64'hA97074FAD68B5F25; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"250511\n"); + end + x = 64'hB7EBFF0000000000; + y = 64'hBCA0000000000000; + z = 64'h8010000000000001; + ans = 64'h349BFF0000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"251125\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC96FFFFFFF8001FF; + z = 64'h40DFFFFFFDFFFFFC; + ans = 64'h40DFFFFFFDFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"251739\n"); + end + x = 64'h801C7B84A75451DD; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h43FFBFFDFFFFFFFF; + ans = 64'h43FFBFFDFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"252353\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3FEBFC64B17CA8B8; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"252967\n"); + end + x = 64'h43FFFFFFFFFE003F; + y = 64'hB9BFFFDFFFF00000; + z = 64'hBE7E335C0C10AACF; + ans = 64'hBE7E375C0810A88F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"253581\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hBFD0000000000000; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"254195\n"); + end + x = 64'hC02FFFFFFEFFEFFF; + y = 64'hBA0FFFFF803FFFFF; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"254809\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hBFD0000000000001; + z = 64'hC3F007DFFFFFFFFE; + ans = 64'hC3F007DFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"255423\n"); + end + x = 64'hB81B6C5020C693B9; + y = 64'h8010A73398D14A63; + z = 64'hBF9C0A2129066A92; + ans = 64'hBF9C0A2129066A92; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"256037\n"); + end + x = 64'hC3D0000000000FBE; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h43C0000000000FBD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"256651\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3E0FFFFC0003FFFE; + z = 64'h37EFFE0000000400; + ans = 64'h37EFFE0000000400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"257265\n"); + end + x = 64'h43EFBFFFFF000000; + y = 64'hBFE0000000000001; + z = 64'h402C00007FFFFFFF; + ans = 64'hC3DFBFFFFF000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"257879\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h41FFDFFFFFFFF000; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"258493\n"); + end + x = 64'h400FFFFFF9FFFFFE; + y = 64'hBFEFFFC000020000; + z = 64'h41E0000047FFFFFF; + ans = 64'h41E00000478000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"259107\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"259721\n"); + end + x = 64'hC0170040464CFE1F; + y = 64'h311C000007FFFFFF; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"260335\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hBFF0000000000000; + z = 64'h43EFFFFF80000001; + ans = 64'h43EFFFFF80000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"260949\n"); + end + x = 64'hC023FFFFFBFFFFFE; + y = 64'hB7E56E0E64D01FD4; + z = 64'hB81306B461C19607; + ans = 64'h37FF0B765B9C3898; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"261563\n"); + end + x = 64'hFFE92C9C9F15452B; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"262177\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h406FFFF80003FFFF; + z = 64'h8022000000000008; + ans = 64'h008FB7F80003FFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"262791\n"); + end + x = 64'h3DBFFFFFFC000000; + y = 64'hC000000000000000; + z = 64'h381FFFFFFFFDFFBF; + ans = 64'hBDCFFFFFFC000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"263405\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC1900000023FFFFF; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"264019\n"); + end + x = 64'hBFDFF0000000003F; + y = 64'hBFD00000000FBFFE; + z = 64'hE06FFFFFFFDBFFFF; + ans = 64'hE06FFFFFFFDBFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"264633\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"265247\n"); + end + x = 64'hC7E0000000007FEF; + y = 64'h381000FFF7FFFFFE; + z = 64'h3FD0000000000000; + ans = 64'hBFFC01FFF000FFEA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"265861\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hD50FFFF7FFC00000; + ans = 64'hD50FFFF7FFC00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"266475\n"); + end + x = 64'hC3E8EC94F987EA69; + y = 64'hB6BFFE000007FFFF; + z = 64'h7FEFFFFFFBFFFFBF; + ans = 64'h7FEFFFFFFBFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"267089\n"); + end + x = 64'hBF205FF2A7EAB3BB; + y = 64'hC010000000000001; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"267703\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h47F0000000007FFD; + z = 64'h7FDFFFFFFFFFFFFF; + ans = 64'h7FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"268317\n"); + end + x = 64'hB5A9CE7F4AAD3C58; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBFE000000020000E; + ans = 64'hBFE000000020000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"268931\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC039B54B40228093; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"269545\n"); + end + x = 64'hBF8FFFFC007FFFFF; + y = 64'h43C00007FFFFFDFF; + z = 64'hBF60800FFFFFFFFE; + ans = 64'hC3600006003EFE1F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"270159\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC340000000000001; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"270773\n"); + end + x = 64'hBF400020007FFFFF; + y = 64'h801423605653ABED; + z = 64'h3CA0000000000001; + ans = 64'h3CA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"271387\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC3C00000040FFFFF; + ans = 64'hC3C00000040FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"272001\n"); + end + x = 64'h3FDFFFFFFFFFFC04; + y = 64'hC3ED280F8FC308D0; + z = 64'hC890000000803FFF; + ans = 64'hC890000000803FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"272615\n"); + end + x = 64'h349FFFFFFFFDFFDF; + y = 64'hFFE0000000000000; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"273229\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC1D03FFFFFFFFFEF; + z = 64'hB7E598841B7B4A99; + ans = 64'hB7E598841B7B4A99; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"273843\n"); + end + x = 64'h2D8FFFFFFFFFFBBE; + y = 64'hFFE0000000000001; + z = 64'h403FC0003FFFFFFE; + ans = 64'hED7FFFFFFFFFFBC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"274457\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hBFDFC00020000000; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"275071\n"); + end + x = 64'h41DFFFF7FFFFFFDE; + y = 64'hFFE0000FFFFF8000; + z = 64'h40357503F165F219; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"275685\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hFFF0000000000000; + z = 64'h4000000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"276299\n"); + end + x = 64'hC2CC000003FFFFFE; + y = 64'h55E7FFFFFFFFFFEE; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hD8C5000002FFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"276913\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hFFF0000000000001; + z = 64'hDD54F217C468808E; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"277527\n"); + end + x = 64'hBFC000000002FFFE; + y = 64'h401FFEFFFFFFFDFF; + z = 64'h405634FB9C49B286; + ans = 64'h4055F4FD9C49A68A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"278141\n"); + end + x = 64'hBFF080003FFFFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"278755\n"); + end + x = 64'h0010000000000000; + y = 64'h43D00FEFFFFFFFFF; + z = 64'hB06EA04ADE201D7F; + ans = 64'hB06EA04ADE201D7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"279369\n"); + end + x = 64'h43C04000000001FE; + y = 64'h0000000000000000; + z = 64'hEE69F3C54C8FF937; + ans = 64'hEE69F3C54C8FF937; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"279983\n"); + end + x = 64'h0010000000000000; + y = 64'hBFB418FF0ADFC0EF; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"280597\n"); + end + x = 64'hC0EFFFFFFF800200; + y = 64'h403000000080FFFF; + z = 64'h3FE0082386A444A3; + ans = 64'hC12FFFFEFFFFC994; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"281211\n"); + end + x = 64'h0010000000000000; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"281825\n"); + end + x = 64'h7260001FFF7FFFFF; + y = 64'h376FEBC83323C3E3; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h69DFEC0809B4CBE7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"282439\n"); + end + x = 64'h0010000000000000; + y = 64'h0010000000000000; + z = 64'hBC555EBEF2DFDF4F; + ans = 64'hBC555EBEF2DFDF4F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"283053\n"); + end + x = 64'hB9AFFFFFFEFFFFEF; + y = 64'hB8001FF800000000; + z = 64'h369A9A31438FD892; + ans = 64'h369A9A31438FD892; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"283667\n"); + end + x = 64'hF0DFFF800000FFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"284281\n"); + end + x = 64'h0010000000000000; + y = 64'hA10FFFFFFFFFFFFF; + z = 64'hC1F312A8C47A6E98; + ans = 64'hC1F312A8C47A6E98; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"284895\n"); + end + x = 64'h3CAFFFFB00000000; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hBEAFFFDFFFFFFFFC; + ans = 64'hBEAFFFDFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"285509\n"); + end + x = 64'h0010000000000000; + y = 64'hB80FFFC000000100; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"286123\n"); + end + x = 64'hC3FFFFFFBFFF7FFF; + y = 64'hBF6200001FFFFFFE; + z = 64'hC0300000001FF7FF; + ans = 64'h4371FFFFFBFFB7BC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"286737\n"); + end + x = 64'h0010000000000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"287351\n"); + end + x = 64'hB54FFFF81FFFFFFF; + y = 64'h41C5D768F450EFAD; + z = 64'h0000000000000000; + ans = 64'hB725D763944E1B8C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"287965\n"); + end + x = 64'h0010000000000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h43DBFFFFFFFFE000; + ans = 64'h43DBFFFFFFFFE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"288579\n"); + end + x = 64'hC3FFDFF7FFFFFFFF; + y = 64'hC139FA0B752F76EF; + z = 64'hBFCFFFDFFFFFF800; + ans = 64'h4549E00AEB376A2B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"289193\n"); + end + x = 64'h7783F12BB577FCCF; + y = 64'h3FD0000000000001; + z = 64'h4010000000000000; + ans = 64'h7763F12BB577FCD0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"289807\n"); + end + x = 64'h0010000000000000; + y = 64'h380E895E8EC54D4B; + z = 64'hC34000000807FFFF; + ans = 64'hC34000000807FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"290421\n"); + end + x = 64'h517A65ACF3CF57EB; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h80100007FFFFFFFF; + ans = 64'h516A65ACF3CF57EA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"291035\n"); + end + x = 64'h0010000000000000; + y = 64'h358FFFF000003FFF; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"291649\n"); + end + x = 64'hB81628C1870235BB; + y = 64'h429AEA3DE2F34B36; + z = 64'h5DBFFFFFFFFEDFFF; + ans = 64'h5DBFFFFFFFFEDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"292263\n"); + end + x = 64'h0010000000000000; + y = 64'h3FE0000000000001; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"292877\n"); + end + x = 64'hBF4A92FFF1A2C1E7; + y = 64'hFFFFFFFFFFFE007F; + z = 64'hFFF0000000000001; + ans = 64'hFFFFFFFFFFFE007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"293491\n"); + end + x = 64'h0010000000000000; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3FCFFFFFFFFFE7FE; + ans = 64'h3FCFFFFFFFFFE7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"294105\n"); + end + x = 64'hBFC000FFFFFFFFEE; + y = 64'h3F5FEB520191C6A8; + z = 64'hC010FFFFFFFFFFE0; + ans = 64'hC011003FDAA16D44; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"294719\n"); + end + x = 64'h401040000000000E; + y = 64'h3FF0000000000000; + z = 64'h4000000000000001; + ans = 64'h401840000000000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"295333\n"); + end + x = 64'h0010000000000000; + y = 64'hC7E0000020FFFFFF; + z = 64'hC0348B6B6CA03F9F; + ans = 64'hC0348B6B6CA03F9F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"295947\n"); + end + x = 64'hC3D00021FFFFFFFF; + y = 64'h3FF0000000000001; + z = 64'hC2BFFFFFFFFFFFFE; + ans = 64'hC3D0002A00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"296561\n"); + end + x = 64'h0010000000000000; + y = 64'hC1D0020100000000; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"297175\n"); + end + x = 64'h3FB003FFFFFFFFBE; + y = 64'hC7F5193A2A17F102; + z = 64'hCEAF8FFFFFFFFFFF; + ans = 64'hCEAF8FFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"297789\n"); + end + x = 64'h0010000000000000; + y = 64'h4000000000000000; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"298403\n"); + end + x = 64'hBE4FFFFFFFC80000; + y = 64'hB80B00BB0700EEC9; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"299017\n"); + end + x = 64'h0010000000000000; + y = 64'h4000000000000001; + z = 64'h43DE9338EEC9F034; + ans = 64'h43DE9338EEC9F034; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"299631\n"); + end + x = 64'h47EA1AD664E290AD; + y = 64'h9228D0339D8A672A; + z = 64'hBB500FFFFFFFFFFA; + ans = 64'hBB500FFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"300245\n"); + end + x = 64'h47EFFFFFFFFE4000; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h480FFFFFFFFE3FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"300859\n"); + end + x = 64'h0010000000000000; + y = 64'h473C6A26FC8DE596; + z = 64'h3440003FFFFFFFF6; + ans = 64'h3440003FFFFFFFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"301473\n"); + end + x = 64'hC7FBFFFFFFFFFE00; + y = 64'h4010000000000000; + z = 64'h3FC0000000000202; + ans = 64'hC81BFFFFFFFFFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"302087\n"); + end + x = 64'h0010000000000000; + y = 64'hC7EFFFFFFF700000; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h880FFFFFFF700000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"302701\n"); + end + x = 64'hBA24007FFFFFFFFF; + y = 64'hBFB0000008000002; + z = 64'hBC2000000800007E; + ans = 64'hBC20000007FEC076; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"303315\n"); + end + x = 64'h0010000000000000; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"303929\n"); + end + x = 64'hB7F02000000FFFFF; + y = 64'hBEBC2752FF417189; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"304543\n"); + end + x = 64'h0010000000000000; + y = 64'h4340000000000000; + z = 64'h403FFFF007FFFFFF; + ans = 64'h403FFFF007FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"305157\n"); + end + x = 64'h380FFFF0001FFFFE; + y = 64'hBFA4BF5ED9CE8C8E; + z = 64'h3FF01000001FFFFF; + ans = 64'h3FF01000001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"305771\n"); + end + x = 64'h3FC001FFFFFFFF7F; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h432001FFFFFFFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"306385\n"); + end + x = 64'h0010000000000000; + y = 64'hC7F686065D1D267B; + z = 64'h800001000000FFFF; + ans = 64'h881686065D1D267B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"306999\n"); + end + x = 64'h43D0000080000000; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h6010007FFFFFFC00; + ans = 64'h6010007FFFFFFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"307613\n"); + end + x = 64'h0010000000000000; + y = 64'hBF4FDFFFFFF7FFFE; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h801003FBFFFFFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"308227\n"); + end + x = 64'hC3E4FFFFFFFFFFFE; + y = 64'hC0600002000003FF; + z = 64'h400F7FFFFFFFFE00; + ans = 64'h44550002A000053D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"308841\n"); + end + x = 64'h0010000000000000; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"309455\n"); + end + x = 64'hBFF0000040100000; + y = 64'hBFF0008000007FFF; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"310069\n"); + end + x = 64'h0010000000000000; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hC7F0000FFF7FFFFE; + ans = 64'hC7F0000FFF7FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"310683\n"); + end + x = 64'hC1DFFFFFFFC0FFFF; + y = 64'h381FFFDFFFFF0000; + z = 64'hBFD2988A0956184C; + ans = 64'hBFD2988A0956184C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"311297\n"); + end + x = 64'hC01FFFFFEFFEFFFE; + y = 64'h7FF0000000000001; + z = 64'h3FE0000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"311911\n"); + end + x = 64'h0010000000000000; + y = 64'hBCA842CEA622C954; + z = 64'hFFD001FFFFFFEFFF; + ans = 64'hFFD001FFFFFFEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"312525\n"); + end + x = 64'h402080003FFFFFFE; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h801F58D78CAAC986; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"313139\n"); + end + x = 64'h0010000000000000; + y = 64'hBE6FFFFFBFFFFFF7; + z = 64'h8000000000000000; + ans = 64'h800000000FFFFFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"313753\n"); + end + x = 64'hBF7804A41F298DA7; + y = 64'hBFBD9545159D35EC; + z = 64'h37EFF807FFFFFFFE; + ans = 64'h3F46343E32A9AFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"314367\n"); + end + x = 64'h0010000000000000; + y = 64'h8000000000000001; + z = 64'h0010000000000000; + ans = 64'h0010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"314981\n"); + end + x = 64'h3C1FF7FFFFF7FFFF; + y = 64'hBF60040000080000; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"315595\n"); + end + x = 64'h0010000000000000; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h47F0000FFFFFFBFF; + ans = 64'h47F0000FFFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"316209\n"); + end + x = 64'hC3DE5E4460AC38DB; + y = 64'h400FFFFDFFFFF000; + z = 64'h7FEFFFFFFC00000F; + ans = 64'h7FEFFFFFFC00000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"316823\n"); + end + x = 64'hC35F7FFFF8000000; + y = 64'h8010000000000000; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"317437\n"); + end + x = 64'h0010000000000000; + y = 64'hFFF0000007FFFF00; + z = 64'h508FFFFFFFFFE3FF; + ans = 64'hFFF8000007FFFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"318051\n"); + end + x = 64'h3065CB9EE72E8EAA; + y = 64'h8010000000000001; + z = 64'hC3F0000200000000; + ans = 64'hC3F0000200000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"318665\n"); + end + x = 64'h0010000000000000; + y = 64'h3FF080000000007F; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"319279\n"); + end + x = 64'h3F20000FFFFFFFBF; + y = 64'hBFFE378573394127; + z = 64'hC0603FC8BEC02138; + ans = 64'hC0603FCAA23A5BE4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"319893\n"); + end + x = 64'h0010000000000000; + y = 64'hBCA0000000000000; + z = 64'h0000000000000001; + ans = 64'h0000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"320507\n"); + end + x = 64'hE8400000047FFFFE; + y = 64'hFFD000100000001F; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"321121\n"); + end + x = 64'h0010000000000000; + y = 64'hBCA0000000000001; + z = 64'h2CBFFFF00FFFFFFF; + ans = 64'h2CBFFFF00FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"321735\n"); + end + x = 64'h401FFFFFFFFC3FFE; + y = 64'h43F0008FFFFFFFFE; + z = 64'hC3F2001000000000; + ans = 64'h441B811BFFFC3FD8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"322349\n"); + end + x = 64'h1D300047FFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"322963\n"); + end + x = 64'h0010000000000000; + y = 64'h41C0020000000007; + z = 64'h43F4002000000000; + ans = 64'h43F4002000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"323577\n"); + end + x = 64'h43C00000FFFEFFFF; + y = 64'hBFD0000000000000; + z = 64'h3E800FFFFFEFFFFE; + ans = 64'hC3A00000FFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"324191\n"); + end + x = 64'h0010000000000000; + y = 64'h3FDFFFFFFFFFF7FC; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"324805\n"); + end + x = 64'hC04D419BE71CFD22; + y = 64'hC05FFFDFFFF7FFFF; + z = 64'hBCAB975B5FA2B241; + ans = 64'h40BD417EA579C59D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"325419\n"); + end + x = 64'h0010000000000000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"326033\n"); + end + x = 64'hBFCEFFFFFFFFFFBF; + y = 64'hC03FFFFFFFFFFFE7; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'h4016FFFFFFFFFFA7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"326647\n"); + end + x = 64'h0010000000000000; + y = 64'hBFE0000000000000; + z = 64'hB76FFFFFFFDFFFDE; + ans = 64'hB76FFFFFFFDFFFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"327261\n"); + end + x = 64'hFFEB046129238D38; + y = 64'h491FFFFBEFFFFFFF; + z = 64'h406FEDFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"327875\n"); + end + x = 64'hE900000000040003; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h6900000000040002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"328489\n"); + end + x = 64'h0010000000000000; + y = 64'hBFEFF000003FFFFF; + z = 64'hC80FFFFFFFFFBFEF; + ans = 64'hC80FFFFFFFFFBFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"329103\n"); + end + x = 64'h8001FFFFFFFFDFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hC07FFFFFFF01FFFE; + ans = 64'hC07FFFFFFF01FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"329717\n"); + end + x = 64'h0010000000000000; + y = 64'h7FD00000007FFFFF; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"330331\n"); + end + x = 64'h403F800001000000; + y = 64'hB92FFDFFF7FFFFFE; + z = 64'hB80FF7FFFF7FFFFE; + ans = 64'hB97F7E08390FEFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"330945\n"); + end + x = 64'h0010000000000000; + y = 64'hBFF0000000000001; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"331559\n"); + end + x = 64'h9D3FFFFFFFF7E000; + y = 64'h6A9B80B7D3CB8215; + z = 64'hBFF0000000000000; + ans = 64'hC7EB80B7D3C48666; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"332173\n"); + end + x = 64'h0010000000000000; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h434FFFFFEFEFFFFE; + ans = 64'h434FFFFFEFEFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"332787\n"); + end + x = 64'hBFCFF7FFF7FFFFFF; + y = 64'h3560000007FFFFC0; + z = 64'h3F1FFE0000001FFF; + ans = 64'h3F1FFE0000001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"333401\n"); + end + x = 64'hBFF08000003FFFFF; + y = 64'hC000000000000001; + z = 64'h0010000000000000; + ans = 64'h4000800000400000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"334015\n"); + end + x = 64'h0010000000000000; + y = 64'hC1FFFFFFF80007FF; + z = 64'hBF50000000003F7E; + ans = 64'hBF50000000003F7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"334629\n"); + end + x = 64'h4800000000000E00; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC00C758EB7D7F0E3; + ans = 64'hC820000000000DFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"335243\n"); + end + x = 64'h0010000000000000; + y = 64'hB81FFE0800000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"335857\n"); + end + x = 64'h3FFF7FFFFFDFFFFF; + y = 64'h37F310487C36B9F7; + z = 64'h7FD0000021FFFFFE; + ans = 64'h7FD0000021FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"336471\n"); + end + x = 64'h0010000000000000; + y = 64'hC010000000000000; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"337085\n"); + end + x = 64'h37E13C55FB73A123; + y = 64'hBBE423B0427AB4FB; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"337699\n"); + end + x = 64'h0010000000000000; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hBFFFDFFFFFFFFDFE; + ans = 64'hBFFFDFFFFFFFFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"338313\n"); + end + x = 64'h000A56DAA543D820; + y = 64'hC7E008FFFFFFFFFF; + z = 64'hA4F0800007FFFFFF; + ans = 64'hA4F0800007FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"338927\n"); + end + x = 64'h3FEFC00000100000; + y = 64'hC340000000000000; + z = 64'h0000000000000001; + ans = 64'hC33FC00000100000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"339541\n"); + end + x = 64'h0010000000000000; + y = 64'hC54FFFFFFF808000; + z = 64'h402C0000003FFFFF; + ans = 64'h402C0000003FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"340155\n"); + end + x = 64'hBDBFFFFF7FFF7FFF; + y = 64'hC340000000000001; + z = 64'h469C88C5CBAF8186; + ans = 64'h469C88C5CBAF8186; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"340769\n"); + end + x = 64'h0010000000000000; + y = 64'h401FFFFC00003FFF; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"341383\n"); + end + x = 64'h402FFFFFFDF80000; + y = 64'h00207FFFFFFBFFFE; + z = 64'hC80FFFFFFFF0000F; + ans = 64'hC80FFFFFFFF0000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"341997\n"); + end + x = 64'h0010000000000000; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"342611\n"); + end + x = 64'h4008FFCC8CB379C8; + y = 64'h4020040000001000; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h4038860C7FD6BFA6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"343225\n"); + end + x = 64'h0010000000000000; + y = 64'hFFE0000000000001; + z = 64'hC03A7FD2CBE40B24; + ans = 64'hC03C7FD2CBE40B24; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"343839\n"); + end + x = 64'h47F0040400000000; + y = 64'h3FD1FFFFFFFF7FFF; + z = 64'hE92013FFFFFFFFFE; + ans = 64'hE92013FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"344453\n"); + end + x = 64'h3FD0000080000004; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"345067\n"); + end + x = 64'h0010000000000000; + y = 64'h3FB3FFFFFFFFFEFE; + z = 64'hC090000000002FFF; + ans = 64'hC090000000002FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"345681\n"); + end + x = 64'hBFEFFFFFFFFBFFFC; + y = 64'hFFF0000000000000; + z = 64'hC1D53CF5FDF3680F; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"346295\n"); + end + x = 64'h0010000000000000; + y = 64'hC03000010000007F; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"346909\n"); + end + x = 64'hAB9FFFFFFFFFF1FE; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hC1C8E09D58BA6A9F; + ans = 64'hC1C8E09D58BA6A9F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"347523\n"); + end + x = 64'h0010000000000000; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"348137\n"); + end + x = 64'h40EFFFFFFFFDFFEE; + y = 64'hBFF0000000000000; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hC0EFFFFFFFFDFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"348751\n"); + end + x = 64'h0010000000000001; + y = 64'h0000000000000000; + z = 64'h001FFFFEFFFFFF7F; + ans = 64'h001FFFFEFFFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"349365\n"); + end + x = 64'h400040000007FFFE; + y = 64'hC020000081FFFFFE; + z = 64'hC1F6CE889A397A6A; + ans = 64'hC1F6CE889B3D7A72; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"349979\n"); + end + x = 64'h40BFFFC000080000; + y = 64'h0000000000000001; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"350593\n"); + end + x = 64'h0010000000000001; + y = 64'h7FDFFFDFEFFFFFFF; + z = 64'h0010003FFFFFFFC0; + ans = 64'h3FFFFFDFF0000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"351207\n"); + end + x = 64'h7FFFFFFFFFF7FF7F; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hB81018316CF58422; + ans = 64'h7FFFFFFFFFF7FF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"351821\n"); + end + x = 64'h0010000000000001; + y = 64'h21A0FEFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"352435\n"); + end + x = 64'hDF00000000FEFFFE; + y = 64'hC3C00000000FDFFF; + z = 64'h3F0FFFFFFFE80000; + ans = 64'h62D00000010EDFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"353049\n"); + end + x = 64'h0010000000000001; + y = 64'h0010000000000001; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"353663\n"); + end + x = 64'hBFC38CD9B19C294A; + y = 64'hBFCFFFFC3FFFFFFE; + z = 64'hBCA0000000000000; + ans = 64'h3FA38CD7671AA668; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"354277\n"); + end + x = 64'h0010000000000001; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hC0800800FFFFFFFE; + ans = 64'hC0800800FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"354891\n"); + end + x = 64'h4338F8B4D98D518E; + y = 64'h38101FFFFFFFEFFE; + z = 64'hFFD0003FFFFF8000; + ans = 64'hFFD0003FFFFF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"355505\n"); + end + x = 64'hC2EFFFFFFFFFD7FF; + y = 64'h3CA0000000000000; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"356119\n"); + end + x = 64'h0010000000000001; + y = 64'hBFEC8B10292FC3DD; + z = 64'hC1CFC000000001FE; + ans = 64'hC1CFC000000001FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"356733\n"); + end + x = 64'h77C00000000010FF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3FEFFFFDEFFFFFFE; + ans = 64'h74800000000010FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"357347\n"); + end + x = 64'h0010000000000001; + y = 64'hC7EFC00000000008; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"357961\n"); + end + x = 64'hB7ED1530D0EED500; + y = 64'hC0FFFFFC000000FF; + z = 64'hC1C613EAB1D2BC41; + ans = 64'hC1C613EAB1D2BC41; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"358575\n"); + end + x = 64'h0010000000000001; + y = 64'h3FD0000000000000; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"359189\n"); + end + x = 64'h4020001000000007; + y = 64'h39AFFFFFFFF7FFFE; + z = 64'h8010000000000001; + ans = 64'h39E0000FFFFC0002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"359803\n"); + end + x = 64'h0010000000000001; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h43405A4963156D9E; + ans = 64'h43405A4963156D9E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"360417\n"); + end + x = 64'h381004000000FFFF; + y = 64'hC03FFFFA00000000; + z = 64'h42F00000006FFFFF; + ans = 64'h42F00000006FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"361031\n"); + end + x = 64'hC800000000480000; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hC340000000000001; + ans = 64'hC7F000000047FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"361645\n"); + end + x = 64'h0010000000000001; + y = 64'hBFCFFFFFFFFFFBFF; + z = 64'h4F5FFFFFDFFFFF7E; + ans = 64'h4F5FFFFFDFFFFF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"362259\n"); + end + x = 64'h41E4A1EAE73D355C; + y = 64'h3FE0000000000001; + z = 64'h37E2ACB70B24ACB2; + ans = 64'h41D4A1EAE73D355D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"362873\n"); + end + x = 64'h0010000000000001; + y = 64'h802FFFFFBC000000; + z = 64'h3FE0000000000001; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"363487\n"); + end + x = 64'h403FFFE000FFFFFE; + y = 64'hFFFFFFFFFFBFFFF0; + z = 64'h402FFEFFFFFFBFFF; + ans = 64'hFFFFFFFFFFBFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"364101\n"); + end + x = 64'h0010000000000001; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"364715\n"); + end + x = 64'h800C0454F11FDD89; + y = 64'h4018F1AF45350CCF; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h8036BC044C7B4FDB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"365329\n"); + end + x = 64'h0010000000000001; + y = 64'h3FF0000000000001; + z = 64'hC09FFFBFFFFFBFFF; + ans = 64'hC09FFFBFFFFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"365943\n"); + end + x = 64'hBE4FC000007FFFFE; + y = 64'hC3D0080040000000; + z = 64'hC03FFFFFFDFFFDFF; + ans = 64'h422FCFE07F404000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"366557\n"); + end + x = 64'hBF80000000008000; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC02008000000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"367171\n"); + end + x = 64'h0010000000000001; + y = 64'hBD0FFFFFD7FFFFFF; + z = 64'hC3D00080003FFFFF; + ans = 64'hC3D00080003FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"367785\n"); + end + x = 64'h7FDFFEFFFFFF7FFE; + y = 64'h4000000000000000; + z = 64'h002FFFFFE000007F; + ans = 64'h7FEFFEFFFFFF7FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"368399\n"); + end + x = 64'h0010000000000001; + y = 64'h3FCFFFFDFFFBFFFF; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"369013\n"); + end + x = 64'h3FFFFE000007FFFF; + y = 64'h41DFFFE000100000; + z = 64'hBFE507C600F1F12A; + ans = 64'h41EFFDE00202F731; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"369627\n"); + end + x = 64'h0010000000000001; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"370241\n"); + end + x = 64'hBCE00000001FFFFB; + y = 64'h400007FF7FFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"370855\n"); + end + x = 64'h0010000000000001; + y = 64'h4010000000000000; + z = 64'h40A0008000000200; + ans = 64'h40A0008000000200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"371469\n"); + end + x = 64'h3FDFF5989FAB38C7; + y = 64'hB810000400000002; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"372083\n"); + end + x = 64'hDE7FFFEFFFFFFFBF; + y = 64'h4010000000000001; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hDE9FFFEFFFFFFFC1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"372697\n"); + end + x = 64'h0010000000000001; + y = 64'h80001FFFF7FFFFFE; + z = 64'hC001FFFFFFFFFFDF; + ans = 64'hC001FFFFFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"373311\n"); + end + x = 64'hC010003FFFFFFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hC1FB6BC37B0AF313; + ans = 64'hC1FB6BC37D0AFB13; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"373925\n"); + end + x = 64'h0010000000000001; + y = 64'hB8BFFFF80000FFFE; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"374539\n"); + end + x = 64'h38A8B771F85C15DA; + y = 64'hBFDFFFFEFFFFFFBE; + z = 64'h3E6FFFFFFC03FFFE; + ans = 64'h3E6FFFFFFC03FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"375153\n"); + end + x = 64'h0010000000000001; + y = 64'h4340000000000001; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"375767\n"); + end + x = 64'h4FCAAD2F5FC33B20; + y = 64'h376FF7EFFFFFFFFE; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"376381\n"); + end + x = 64'h0010000000000001; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC007F2D5B3D5ED32; + ans = 64'hC007F2D5B3D5ED32; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"376995\n"); + end + x = 64'h402FFFFBFFFFFBFF; + y = 64'hC7E659F40C826256; + z = 64'hBFEC06F9894A7A32; + ans = 64'hC82659F14143DDFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"377609\n"); + end + x = 64'hBCAF5F38CB074578; + y = 64'h7FE0000000000000; + z = 64'hC000000000000000; + ans = 64'hFC9F5F38CB074578; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"378223\n"); + end + x = 64'h0010000000000001; + y = 64'hC01FEFFFFFFF8000; + z = 64'h3FB7FFFFFFFFFFDF; + ans = 64'h3FB7FFFFFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"378837\n"); + end + x = 64'h3DCD677997FE3E3B; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hFAC3698D88B4775C; + ans = 64'h7DCD677997FE3E27; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"379451\n"); + end + x = 64'h0010000000000001; + y = 64'h56600000FFFDFFFE; + z = 64'h3CA0000000000000; + ans = 64'h3CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"380065\n"); + end + x = 64'hC5D0080000800000; + y = 64'hB930008001FFFFFF; + z = 64'h43FFFFFFFFFFFF83; + ans = 64'h43FFFFFFFFFFFF83; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"380679\n"); + end + x = 64'h0010000000000001; + y = 64'h7FF0000000000000; + z = 64'hBFD0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"381293\n"); + end + x = 64'hBFC4EC65823F040A; + y = 64'h8DDFFFFFE0000400; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"381907\n"); + end + x = 64'h0010000000000001; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hFFD07FF7FFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"382521\n"); + end + x = 64'h41BFFFFFF7FFF000; + y = 64'hC19E0AA274921E95; + z = 64'hC2CFFFFFFE001FFE; + ans = 64'hC36E12A26D0EE6FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"383135\n"); + end + x = 64'hBCF1FFFFFFFFFEFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"383749\n"); + end + x = 64'h0010000000000001; + y = 64'hFFF205635E5BC7FC; + z = 64'hC7F200000003FFFF; + ans = 64'hFFFA05635E5BC7FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"384363\n"); + end + x = 64'h41CFFFFFFFEFFFE0; + y = 64'h8000000000000001; + z = 64'h41D1CDB29820C684; + ans = 64'h41D1CDB29820C684; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"384977\n"); + end + x = 64'h0010000000000001; + y = 64'hC80FFFF000400000; + z = 64'h0010000000000001; + ans = 64'h882FFFF000400002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"385591\n"); + end + x = 64'h41DFFFFBFFFFFFFF; + y = 64'hFEB3FFFFFFFFFFFF; + z = 64'h39BEFFFFFFF80000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"386205\n"); + end + x = 64'h0010000000000001; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"386819\n"); + end + x = 64'h43D4347C467523C5; + y = 64'h3CF0003FFFFFFFF7; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h4350000000001434; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"387433\n"); + end + x = 64'h0010000000000001; + y = 64'h8010000000000001; + z = 64'hC1D0E21DDC57C6F2; + ans = 64'hC1D0E21DDC57C6F2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"388047\n"); + end + x = 64'h3FAEC83956AF6BDA; + y = 64'h47EFFFFFFFF007FF; + z = 64'h2DBBA7D5393B1408; + ans = 64'h47AEC83956A00F6E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"388661\n"); + end + x = 64'hBFB543040DD1458A; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"389275\n"); + end + x = 64'h0010000000000001; + y = 64'hD5687D0C01D0A5C0; + z = 64'hC37FFFFFFDFFFDFE; + ans = 64'hC37FFFFFFDFFFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"389889\n"); + end + x = 64'hC03DB75E6B3453F3; + y = 64'hBCA0000000000000; + z = 64'hC56FFBFFEFFFFFFE; + ans = 64'hC56FFBFFEFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"390503\n"); + end + x = 64'h0010000000000001; + y = 64'h437FFFFF3FFFFFFF; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h039FFFFF40000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"391117\n"); + end + x = 64'h42170719F6674DF0; + y = 64'hBFCFF800000003FF; + z = 64'h41D0007F7FFFFFFF; + ans = 64'hC1F301384FE9B6FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"391731\n"); + end + x = 64'h0010000000000001; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h8020000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"392345\n"); + end + x = 64'h3FBFFFFE01FFFFFF; + y = 64'hBEBFFFFFFFF00800; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFF00000FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"392959\n"); + end + x = 64'h0010000000000001; + y = 64'hBFD0000000000000; + z = 64'h41E0008000000002; + ans = 64'h41E0008000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"393573\n"); + end + x = 64'h3FB11BFBA3DA9D75; + y = 64'hCF2FFFFF81FFFFFF; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hCEF11BFB607C6E9F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"394187\n"); + end + x = 64'hC730000400000003; + y = 64'hBFD0000000000001; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h4710000400000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"394801\n"); + end + x = 64'h0010000000000001; + y = 64'h414FF0000000001F; + z = 64'h3FFBFFFFFFFFFEFE; + ans = 64'h3FFBFFFFFFFFFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"395415\n"); + end + x = 64'h41D00FFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h3FF6FFBCCC05FB7F; + ans = 64'hC1C00FFFFF480218; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"396029\n"); + end + x = 64'h0010000000000001; + y = 64'h7FE40000003FFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"396643\n"); + end + x = 64'h5B31FBFFFFFFFFFE; + y = 64'h401001FFFFFFFFF6; + z = 64'h1150000FFFF7FFFE; + ans = 64'h5B51FE3F7FFFFFF3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"397257\n"); + end + x = 64'h0010000000000001; + y = 64'hBFE0000000000001; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h8017FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"397871\n"); + end + x = 64'h41DFFFDF7FFFFFFF; + y = 64'hC6B0001007FFFFFE; + z = 64'h4010000000000000; + ans = 64'hC89FFFFF8FDF6FBB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"398485\n"); + end + x = 64'h0010000000000001; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hCE2FFFEFFFFFFC00; + ans = 64'hCE2FFFEFFFFFFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"399099\n"); + end + x = 64'hBFFFFFFFAFFFFFFE; + y = 64'hC340400000FFFFFF; + z = 64'hBF0FFFBFFFF80000; + ans = 64'h43503FFFD85FFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"399713\n"); + end + x = 64'h3FCB24DCD9C1D121; + y = 64'hBFF0000000000000; + z = 64'hBFD0000000000000; + ans = 64'hBFDD926E6CE0E890; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"400327\n"); + end + x = 64'h0010000000000001; + y = 64'hC1CFFF7FFFFFFE00; + z = 64'h3FE00000003FFC00; + ans = 64'h3FE00000003FFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"400941\n"); + end + x = 64'hBE1000003FFFFFBF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hC34FF000003FFFFE; + ans = 64'hC34FF000003FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"401555\n"); + end + x = 64'h0010000000000001; + y = 64'h657003FFFFFFFC00; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"402169\n"); + end + x = 64'h000B911E4CBDACCE; + y = 64'h39804000000003FF; + z = 64'h00139BDEF80EC19D; + ans = 64'h00139BDEF80EC19D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"402783\n"); + end + x = 64'h0010000000000001; + y = 64'hC000000000000000; + z = 64'h8000000000000000; + ans = 64'h8020000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"403397\n"); + end + x = 64'h402FFFFFFC003FFE; + y = 64'hFFDF800010000000; + z = 64'h4000000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"404011\n"); + end + x = 64'h0010000000000001; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h3FC0003FFFFF7FFF; + ans = 64'h3FC0003FFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"404625\n"); + end + x = 64'hFFE00000000010FE; + y = 64'h94432AB61CDBA523; + z = 64'h3E3BFFFFFFFFBFFE; + ans = 64'h54332AB61CDBB97E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"405239\n"); + end + x = 64'h178FFFFFFFEFDFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"405853\n"); + end + x = 64'h0010000000000001; + y = 64'h41EFFFFFFFFFFF7F; + z = 64'h47FFFFFFFFFFFFC1; + ans = 64'h47FFFFFFFFFFFFC1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"406467\n"); + end + x = 64'h3CAFFFDBFFFFFFFF; + y = 64'hC010000000000001; + z = 64'h41D000FC00000000; + ans = 64'h41D000FC00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"407081\n"); + end + x = 64'h0010000000000001; + y = 64'hB7F989C602E18CB6; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"407695\n"); + end + x = 64'hC0068C39C8421A45; + y = 64'h3EF00000207FFFFE; + z = 64'hBFD000000003FFBF; + ans = 64'hBFD000B461D3B036; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"408309\n"); + end + x = 64'h0010000000000001; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"408923\n"); + end + x = 64'hC1DFFF6FFFFFFFFF; + y = 64'hBB80000000000102; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h40000000000007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"409537\n"); + end + x = 64'h0010000000000001; + y = 64'hC340000000000001; + z = 64'h3FCFFFFEFFFFDFFE; + ans = 64'h3FCFFFFEFFFFDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"410151\n"); + end + x = 64'h3C7FFFFFF8008000; + y = 64'hC806EE1414AFC71A; + z = 64'h3D10D39F6CFAD054; + ans = 64'hC496EE140EF49DCD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"410765\n"); + end + x = 64'h3E212A83DE6986F5; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'hC1812A83DE6986F4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"411379\n"); + end + x = 64'h0010000000000001; + y = 64'h3FE00000201FFFFF; + z = 64'h3FEFFFFFFF8000FF; + ans = 64'h3FEFFFFFFF8000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"411993\n"); + end + x = 64'h4807FFFDFFFFFFFE; + y = 64'hFFE0000000000000; + z = 64'h45B00000100003FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"412607\n"); + end + x = 64'h0010000000000001; + y = 64'hC1DFFFFFC00FFFFF; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"413221\n"); + end + x = 64'h4C90080000007FFF; + y = 64'h4180007DFFFFFFFF; + z = 64'hB7FFFCFFFFFFFFFF; + ans = 64'h4E20087E3F008002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"413835\n"); + end + x = 64'h0010000000000001; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"414449\n"); + end + x = 64'hC67D0752856A715F; + y = 64'hB2E000000BFFFFFF; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"415063\n"); + end + x = 64'h0010000000000001; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hD5900001FFFF7FFF; + ans = 64'hD5900001FFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"415677\n"); + end + x = 64'h401FFF8003FFFFFF; + y = 64'hFFEFFFFFFFFDFFFF; + z = 64'hBFBFF7FFFFFFEFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"416291\n"); + end + x = 64'h383FE00000001FFF; + y = 64'hFFF0000000000001; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"416905\n"); + end + x = 64'h0010000000000001; + y = 64'h403FFFFBFFFFE000; + z = 64'hCC7DFFFFFFFFBFFE; + ans = 64'hCC7DFFFFFFFFBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"417519\n"); + end + x = 64'h47EFF87FFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h00080001FFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"418133\n"); + end + x = 64'h0010000000000001; + y = 64'h3FD43FFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"418747\n"); + end + x = 64'h41E1FFFFFFFFFFEF; + y = 64'hF3303EFFFFFFFFFF; + z = 64'h46BFFFFFFF001FFF; + ans = 64'hF52246DFFFFFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"419361\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h0000000000000001; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"419975\n"); + end + x = 64'h3FD007FFFF7FFFFE; + y = 64'h3FFFFFFFFBFFFEFF; + z = 64'h3FE0000000000000; + ans = 64'h3FF003FFFEBF7FBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"420589\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h396C5680AC81324C; + ans = 64'h396C5680AC81324C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"421203\n"); + end + x = 64'hBFF0000000004006; + y = 64'h3800002000000006; + z = 64'hA7700FF000000000; + ans = 64'hB80000200000400D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"421817\n"); + end + x = 64'hA2EFFFFFFFF7FC00; + y = 64'h0010000000000000; + z = 64'h8000000000000000; + ans = 64'h8000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"422431\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hDE40000000140000; + z = 64'h3E17FFFEFFFFFFFF; + ans = 64'h3E17FFFEFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"423045\n"); + end + x = 64'hBFF000007FEFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hBF7000FFBFFFFFFF; + ans = 64'hBF7000FFBFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"423659\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h5FF000000000FF80; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"424273\n"); + end + x = 64'h37F2018CDBC5E6EC; + y = 64'h3FD010007FFFFFFF; + z = 64'h3FDF87FFFFFFFFFF; + ans = 64'h3FDF87FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"424887\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3CA0000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"425501\n"); + end + x = 64'h434040000000003E; + y = 64'hB81FFFFFFF7FFFFF; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"426115\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3CA0000000000001; + z = 64'h402FFFFFFEFFFF7F; + ans = 64'h402FFFFFFEFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"426729\n"); + end + x = 64'hC3E001FFFFFBFFFF; + y = 64'hBFCFFFFC003FFFFE; + z = 64'h3FD000007FFFF800; + ans = 64'h43C001FDFFDC03FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"427343\n"); + end + x = 64'hB7F00001FEFFFFFE; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"427957\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h401FFFFBFFFFFFFE; + z = 64'h7FEDF7FFFFFFFFFE; + ans = 64'h7FEDF7FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"428571\n"); + end + x = 64'hB97000010000FFFF; + y = 64'h3FD0000000000001; + z = 64'hCDABA05ECB7D8187; + ans = 64'hCDABA05ECB7D8187; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"429185\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h800FFFFBFC000000; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"429799\n"); + end + x = 64'hBFDC8AD94D9D9EA7; + y = 64'hBF1FFFFFDFFF0000; + z = 64'hC1E04000001FFFFE; + ans = 64'hC1E04000001FFF8C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"430413\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"431027\n"); + end + x = 64'h403EE56F7508D6C4; + y = 64'h3E2FFFBFFFFFFF7F; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3E7EE531AB29EC36; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"431641\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3FE0000000000000; + z = 64'h410F7FFFFFFFFBFF; + ans = 64'h410F7FFFFFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"432255\n"); + end + x = 64'hBFFFFFFF9FFFFFFF; + y = 64'h3FC000BFFFFFFFFE; + z = 64'h47FE4FE7FC5CA94B; + ans = 64'h47FE4FE7FC5CA94B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"432869\n"); + end + x = 64'h3EF00000000007FD; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"433483\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h8000ADABC1083601; + z = 64'h7A500003FFFFFFDF; + ans = 64'h7A500003FFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"434097\n"); + end + x = 64'hC3C100000003FFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h80001FFFFFFFFEFF; + ans = 64'hC3C100000003FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"434711\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hBD5000000FDFFFFE; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"435325\n"); + end + x = 64'hC14EFFFFFFFFFFF0; + y = 64'hBB7F00000007FFFE; + z = 64'h401FFFEFFFFFFFF6; + ans = 64'h401FFFEFFFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"435939\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"436553\n"); + end + x = 64'hBD8FE00020000000; + y = 64'h43FBD1AA550D93D7; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'hC19BB5D8C68A3098; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"437167\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h37F3FFFFFBFFFFFE; + ans = 64'h37F3FFFFFBFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"437781\n"); + end + x = 64'h7FEE640EDD7D325B; + y = 64'hBF9FFEFFFFF80000; + z = 64'hC6FFC00000000000; + ans = 64'hFF9E631BBCFEAD6E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"438395\n"); + end + x = 64'hC00000000FFFDFFF; + y = 64'h4000000000000001; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"439009\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hC7FFFFFF00000004; + z = 64'h3F771D032C61EC36; + ans = 64'h3F771D032C61EC36; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"439623\n"); + end + x = 64'h41E76CC19771603B; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hCD70020000800000; + ans = 64'hCD70020000800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"440237\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3FEDFFFFFFFFFFF0; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"440851\n"); + end + x = 64'h001FFFFFFFFFFF02; + y = 64'h39FEC6BF7D1B70B5; + z = 64'h9DC000000001FFBE; + ans = 64'h9DC000000001FFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"441465\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h4010000000000001; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"442079\n"); + end + x = 64'h7FE00000000007F7; + y = 64'hCBDFFFFFFFFFFFFF; + z = 64'h0010000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"442693\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h41CFFFFFFFF07FFF; + ans = 64'h41CFFFFFFFF07FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"443307\n"); + end + x = 64'h40B318ECB7EB7D19; + y = 64'h3FF51305D82EA9EE; + z = 64'hC3FFBFFFFFFFFFBF; + ans = 64'hC3FFBFFFFFFFFFBD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"443921\n"); + end + x = 64'h3FD65C4920561A4B; + y = 64'h4340000000000000; + z = 64'h4340000000000000; + ans = 64'h4345971248158693; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"444535\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hC002673D3605EDFC; + z = 64'hFFF0001000FFFFFF; + ans = 64'hFFF8001000FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"445149\n"); + end + x = 64'h43C000020000003E; + y = 64'h4340000000000001; + z = 64'hC00000003FFFFFBF; + ans = 64'h471000020000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"445763\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hB7EFFFFFFFFFFF80; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"446377\n"); + end + x = 64'h42DFFFFFFFE7FFFF; + y = 64'h37ED7BB22AE6852A; + z = 64'hBFCFFFFFFFFFFFEF; + ans = 64'hBFCFFFFFFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"446991\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'h3FF0000000000000; + ans = 64'h4014000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"447605\n"); + end + x = 64'h802000003FFFFBFF; + y = 64'hC3CFFFFFFFFFFFD7; + z = 64'h0000000000000001; + ans = 64'h040000003FFFFBEA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"448219\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h7FE0000000000001; + z = 64'h43E3FFFF80000000; + ans = 64'h43E3FFFF80000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"448833\n"); + end + x = 64'hC3423795C42FF6F8; + y = 64'hC070043FFFFFFFFF; + z = 64'hBFDCEB966144812B; + ans = 64'h43C23C6C87F813B4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"449447\n"); + end + x = 64'h400FFFF87FFFFFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h4010000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"450061\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h413C7FD643DAF76F; + z = 64'hC05D90A520010B43; + ans = 64'hC05D90A520010B43; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"450675\n"); + end + x = 64'h4220040000080000; + y = 64'h7FF0000000000000; + z = 64'hB7F2E64B75544CD9; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"451289\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h40E00000002FFFFE; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"451903\n"); + end + x = 64'h37F00000000017FE; + y = 64'hBFDC9E6C8A133CA5; + z = 64'h39EEFFFFFFFFFFFF; + ans = 64'h39EEFFFFFFF1B0C9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"452517\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3FE0000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"453131\n"); + end + x = 64'hC130000000007FDF; + y = 64'h3CABD2A0BF65E45F; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"453745\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h8000000000000000; + z = 64'hC1CFB2531402EC4E; + ans = 64'hC1CFB2531402EC4E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"454359\n"); + end + x = 64'hB29C35CB8E00D8E6; + y = 64'hC3402000000001FF; + z = 64'hC0F7FBFFFFFFFFFE; + ans = 64'hC0F7FBFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"454973\n"); + end + x = 64'hBFAFFFFEFFFFFFC0; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"455587\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h4800040000003FFE; + z = 64'hBFED31C40B4B727C; + ans = 64'hBFED31C40B4B727C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"456201\n"); + end + x = 64'h402206EC0CADFB89; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"456815\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3F0FDFFFFEFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"457429\n"); + end + x = 64'h400FF40000000000; + y = 64'hC3E00FFFEFFFFFFF; + z = 64'h229FEFFFFFFFF7FF; + ans = 64'hC40009F9F005FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"458043\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"458657\n"); + end + x = 64'h916FFFFFFFDDFFFF; + y = 64'h3FF3FFFFFEFFFFFF; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"459271\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h4664AF10B2B4831C; + ans = 64'h4664AF10B2B4831C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"459885\n"); + end + x = 64'hB03000000DFFFFFF; + y = 64'h41E0040000000200; + z = 64'hC034966F42C45187; + ans = 64'hC034966F42C45187; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"460499\n"); + end + x = 64'hC32BC7B859BF9991; + y = 64'hBCA0000000000001; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h400378F70B37F331; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"461113\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hBFE000007DFFFFFE; + z = 64'hBCAFFFFFFFFFFE3F; + ans = 64'hBCAFFFFFFFFFFE3F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"461727\n"); + end + x = 64'hC0200000401FFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h43FFF7FFFFFFFF7F; + ans = 64'h43FFF7FFFFFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"462341\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h41F5D9F10DF04721; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h0225D9F10DE04720; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"462955\n"); + end + x = 64'h780C28A279108114; + y = 64'h65C7CB88671E9840; + z = 64'hC8004B04A2AE6C6C; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"463569\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hBFD0000000000001; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"464183\n"); + end + x = 64'h4023FFFFFFFC0000; + y = 64'hC02FFFFFFFDDFFFF; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"464797\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC13FFDFFFFFFFFDF; + ans = 64'hC13FFDFFFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"465411\n"); + end + x = 64'hBFFFE003FFFFFFFE; + y = 64'h3FD0800000000000; + z = 64'h380FFFFBFFFFFFFF; + ans = 64'hBFE06F820FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"466025\n"); + end + x = 64'hBFE00000080003FF; + y = 64'hBFE0000000000000; + z = 64'h3FF0000000000000; + ans = 64'h3FF4000002000100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"466639\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h47FFFFFFFFFFEBFE; + z = 64'h3F38CD81E06C497A; + ans = 64'h3F38CD81E06C497A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"467253\n"); + end + x = 64'hB810000000000803; + y = 64'hBFE0000000000001; + z = 64'hC3DDFFFFFFFFFFBE; + ans = 64'hC3DDFFFFFFFFFFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"467867\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hB80FFFFFFFF7BFFF; + z = 64'h8010000000000000; + ans = 64'h8010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"468481\n"); + end + x = 64'h3EFFFFFFFFEFFF00; + y = 64'h400000000000400F; + z = 64'hC8000200003FFFFF; + ans = 64'hC8000200003FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"469095\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hBFF0000000000000; + z = 64'h3CA0000000000000; + ans = 64'h3CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"469709\n"); + end + x = 64'h432FFFFFFFFFFF03; + y = 64'h4800000004000040; + z = 64'hC340000000000001; + ans = 64'h4B40000003FFFFC1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"470323\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hBFF0000000000001; + z = 64'hC3FED13CC475191F; + ans = 64'hC3FED13CC475191F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"470937\n"); + end + x = 64'h3FEFFFFFFFDF7FFE; + y = 64'hFFF50D33EA30BABA; + z = 64'hB7EFFFFFFFFFFFE7; + ans = 64'hFFFD0D33EA30BABA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"471551\n"); + end + x = 64'h000FE0000001FFFE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h3FE0000000000001; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"472165\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hBFFFFBEFFFFFFFFF; + z = 64'hC1FFFFFFFFFFF80F; + ans = 64'hC1FFFFFFFFFFF80F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"472779\n"); + end + x = 64'h42507FFFFFFFFEFF; + y = 64'hC000000000000000; + z = 64'h3FA1F463B7BB4598; + ans = 64'hC2607FFFFFFFFDE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"473393\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h47FFFFFE03FFFFFF; + z = 64'h8000000000000001; + ans = 64'h082FFFFE03FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"474007\n"); + end + x = 64'h401F000000000007; + y = 64'hFFFFFEFDFFFFFFFF; + z = 64'h768FFFFFBFFFFF80; + ans = 64'hFFFFFEFDFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"474621\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h0010000000000001; + ans = 64'h803BFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"475235\n"); + end + x = 64'h43E872992068804E; + y = 64'h1ABFFDFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"475849\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hC010000000000000; + z = 64'h43C0010080000000; + ans = 64'h43C0010080000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"476463\n"); + end + x = 64'h4190000000000010; + y = 64'h3FF6881A2C6EC3DE; + z = 64'h7FEFFFBFFEFFFFFF; + ans = 64'h7FEFFFBFFEFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"477077\n"); + end + x = 64'hB7F58D085BCBA2EF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"477691\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hC03FFFFBFFFF7FFE; + z = 64'h7FE000FFFFFFFBFF; + ans = 64'h7FE000FFFFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"478305\n"); + end + x = 64'h403EFFFFFFFBFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hC42DDFFFFFFFFFFF; + ans = 64'hC42DDFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"478919\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3FCFFF0000001000; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"479533\n"); + end + x = 64'h380FFFFFFFFFF803; + y = 64'h4038000007FFFFFF; + z = 64'hBFB00000000002FF; + ans = 64'hBFB00000000002FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"480147\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h837FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"480761\n"); + end + x = 64'h8FCFC0000000000F; + y = 64'hC396E75DCC0BEDB1; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"481375\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h380E84D8FBC60A34; + ans = 64'h380E84D8FBC60A34; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"481989\n"); + end + x = 64'h402F800008000000; + y = 64'hC9200003FFFDFFFE; + z = 64'hC3E3B93E1C073F21; + ans = 64'hC95F8007E7FC11FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"482603\n"); + end + x = 64'h39B00000FFFFFF7E; + y = 64'hFFE0000000000001; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'hF9A00000FFFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"483217\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3814040000000000; + z = 64'hBFFB9BC145D76013; + ans = 64'hBFFB9BC145D76013; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"483831\n"); + end + x = 64'hB81FFFFBFFFFFFEE; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hC8BBFDFFFFFFFFFE; + ans = 64'h781FFFFBFFFFFFED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"484445\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hC7F0002000000040; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"485059\n"); + end + x = 64'hBE70000000400010; + y = 64'h41298E77258CB436; + z = 64'hBE801FFFFFFFFFE0; + ans = 64'hBFA98E7B2DF2EE2C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"485673\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hFFF0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"486287\n"); + end + x = 64'h4FB01FFFFFFF0000; + y = 64'h3FF9AB4DFB9A7412; + z = 64'hC000000000000000; + ans = 64'h4FB9DEA497900E45; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"486901\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hC04FFFFFFFFC0003; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"487515\n"); + end + x = 64'h43FFF2FFF2870904; + y = 64'h8B97AB5EF0099570; + z = 64'hBA5FEFFBFFFFFFFE; + ans = 64'hBA5FEFFBFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"488129\n"); + end + x = 64'h41E020000007FFFF; + y = 64'h0000000000000000; + z = 64'h3CA0000000000000; + ans = 64'h3CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"488743\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hC3D6A3A9253C9470; + z = 64'h3FB000000000013F; + ans = 64'h3FB000000000013F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"489357\n"); + end + x = 64'hDC10000000001EFF; + y = 64'h0000000000000001; + z = 64'h802D63F274ADA691; + ans = 64'h98F0000000001EFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"489971\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFC007FFFFFFFFFB; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"490585\n"); + end + x = 64'hBFD200007FFFFFFF; + y = 64'hC34B916DE7248984; + z = 64'hC1CF67F6D68E7232; + ans = 64'h432F039C02F4AE92; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"491199\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"491813\n"); + end + x = 64'h408FFFFFFFF003FF; + y = 64'hBFF01DFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hC09021FFFFF7F302; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"492427\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h0010000000000001; + z = 64'h800E000000002000; + ans = 64'h800E000000002000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"493041\n"); + end + x = 64'hC1CFFFFFEFFDFFFF; + y = 64'h402DFFFFFFFFFF80; + z = 64'hC1D00400003FFFFF; + ans = 64'hC210003FF8830FBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"493655\n"); + end + x = 64'h3FD3D4BA52CE9C8D; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h0010000000000001; + ans = 64'h0019EA5D29674E47; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"494269\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFC7E; + z = 64'hC00FFFFFFFFFFDDF; + ans = 64'hC00FFFFFFFFFFDDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"494883\n"); + end + x = 64'h0C8FFFFC000000FF; + y = 64'h3CA0000000000000; + z = 64'hC051E56F7DD285F6; + ans = 64'hC051E56F7DD285F6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"495497\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFEFFFFE07FFFFFE; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"496111\n"); + end + x = 64'hC02FFFFFFFC01FFF; + y = 64'hC7CF107CC9D31F6F; + z = 64'h801E5BA459AF6A18; + ans = 64'h480F107CC9951D85; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"496725\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"497339\n"); + end + x = 64'h7FEDD366C08DD3A9; + y = 64'hC28FFFDEFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"497953\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h3FD0000000000000; + z = 64'hBFEFF5FFFFFFFFFF; + ans = 64'hBFEFF5FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"498567\n"); + end + x = 64'h3FF0000000200FFF; + y = 64'hC7E0FFFFFFFF0000; + z = 64'hC352890E4983B6C0; + ans = 64'hC7E10000002110FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"499181\n"); + end + x = 64'hB815E5AD5F1699AF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hB805E5AD5F1699AE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"499795\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFC010000000000F; + z = 64'h3FE0000017FFFFFF; + ans = 64'h3FE0000017FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"500409\n"); + end + x = 64'hC3F000000000BFFE; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3F4FFFFFFFFFFF3E; + ans = 64'hC3E000000000BFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"501023\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hC03FC01000000000; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"501637\n"); + end + x = 64'h801000009FFFFFFE; + y = 64'h452CFCD0228D0030; + z = 64'h7FD000FFFFFF8000; + ans = 64'h7FD000FFFFFF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"502251\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h3FE0000000000001; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"502865\n"); + end + x = 64'hBF844323FF911B3D; + y = 64'h8E2FFFFFF0000002; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"503479\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hFFE00020000003FF; + ans = 64'hFFE00020000003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"504093\n"); + end + x = 64'hC66000FFFBFFFFFE; + y = 64'h44F0003FEFFFFFFF; + z = 64'h41DFFFFFFC0007FE; + ans = 64'hCB60013FEFFEF001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"504707\n"); + end + x = 64'h3847AC8111864E13; + y = 64'h3FF0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"505321\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h47EFFFFFFF400000; + z = 64'h39D801FFFFFFFFFE; + ans = 64'h39D801FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"505935\n"); + end + x = 64'hA4C0020003FFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC3DFFEFFFFFDFFFF; + ans = 64'hC3DFFEFFFFFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"506549\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hFFF000100000003F; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'hFFF800100000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"507163\n"); + end + x = 64'h40300000101FFFFF; + y = 64'h403CC2DCC09CCB9F; + z = 64'hBFFFFFFFF8000100; + ans = 64'h407CA2DCDDA12E16; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"507777\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h4000000000000000; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"508391\n"); + end + x = 64'h3FF0000000000806; + y = 64'hBFE00000000000FF; + z = 64'hBFD0000000000000; + ans = 64'hBFE8000000000905; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"509005\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h3FEBFFFFC0000000; + ans = 64'h3FEBFFFFC0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"509619\n"); + end + x = 64'h8E70000000080004; + y = 64'hBF4FFFFFFFC0001E; + z = 64'hC03FFFF000000001; + ans = 64'hC03FFFF000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"510233\n"); + end + x = 64'hFFF7211EB044CF02; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hFFF0000000000000; + ans = 64'hFFFF211EB044CF02; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"510847\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFCBFF7FFFFFFFFF; + z = 64'h43C0040000007FFE; + ans = 64'h43C0040000007FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"511461\n"); + end + x = 64'hC123FFFFFBFFFFFF; + y = 64'h4010000000000001; + z = 64'hC8000001FFFFFFEF; + ans = 64'hC8000001FFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"512075\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h41CFFFFE00001FFE; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"512689\n"); + end + x = 64'h2AECFBC4733AA5DB; + y = 64'hC02FFDFFFFF7FFFF; + z = 64'hDD107FFFFFF7FFFF; + ans = 64'hDD107FFFFFF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"513303\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"513917\n"); + end + x = 64'hBFE007FFFFFFFFEF; + y = 64'h80200000000000FF; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"514531\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h4340000000000001; + z = 64'h43DFFFE00007FFFF; + ans = 64'h43DFFFE00007FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"515145\n"); + end + x = 64'hBCAFFFFFFFFC0FFE; + y = 64'h37E0FFFFFFC00000; + z = 64'hBFB3A6E10298147B; + ans = 64'hBFB3A6E10298147B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"515759\n"); + end + x = 64'hBFD00000000200FE; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"516373\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h3FE02FFFFFFFFFFE; + z = 64'h328FBFFFFFFFFEFE; + ans = 64'h328FBFFFFFFFFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"516987\n"); + end + x = 64'hC2BFF00000000006; + y = 64'h7FE0000000000000; + z = 64'h3F6FFC00000FFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"517601\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFB0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"518215\n"); + end + x = 64'hC03FFFFFFFFFC00E; + y = 64'hC1C000007C000000; + z = 64'h434FFFFDFFFDFFFF; + ans = 64'h434FFFFFFFFE0F7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"518829\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hC000000000000001; + ans = 64'h4017FFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"519443\n"); + end + x = 64'h801FFBFFFFDFFFFE; + y = 64'h002C7FFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h801FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"520057\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h7FF0000000000000; + z = 64'hC4A7AD9414DA3394; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"520671\n"); + end + x = 64'hC07815AA5F6B0FEC; + y = 64'hC8F0000007FBFFFE; + z = 64'h381FFFC0000FFFFE; + ans = 64'h497815AA6B6FDFAE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"521285\n"); + end + x = 64'h41E833C7BBCD2C9D; + y = 64'h7FF0000000000001; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"521899\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h3FE8001FFFFFFFFE; + z = 64'h3EEF8000001FFFFF; + ans = 64'h3EEF8000001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"522513\n"); + end + x = 64'h40CFFFEFFFFFFC00; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC7EFFFFFF5FFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"523127\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hC3FFFFFC001FFFFF; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"523741\n"); + end + x = 64'hC0BFFFFFFDFFC000; + y = 64'h37E00080000003FF; + z = 64'h480D3EE09C1ED5B4; + ans = 64'h480D3EE09C1ED5B4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"524355\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h8000000000000001; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"524969\n"); + end + x = 64'h380FFFFFBFFFFFF7; + y = 64'h41D000000FBFFFFF; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h39EFFFFFDF7FFFB6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"525583\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h4007A97DE77E4C18; + ans = 64'h4007A97DE77E4C18; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"526197\n"); + end + x = 64'hC3F3FFFF7FFFFFFE; + y = 64'h47EFFFFF000001FF; + z = 64'hC0301FFFFC000000; + ans = 64'hCBF3FFFEE000053D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"526811\n"); + end + x = 64'h41CFB516C073EDBC; + y = 64'h8010000000000000; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"527425\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h2E8FFFFEC0000000; + z = 64'h40E090744244D531; + ans = 64'h40E090744244D531; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"528039\n"); + end + x = 64'h46910000003FFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hC008371E39861C0C; + ans = 64'hC008371E39861C0C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"528653\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h002F50F3A5D280F0; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"529267\n"); + end + x = 64'h41F0000000001000; + y = 64'hBE00000001F7FFFF; + z = 64'hC00DD214F016BF5E; + ans = 64'hC016E90A790767AF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"529881\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBCA0000000000000; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"530495\n"); + end + x = 64'hBFDA764348037620; + y = 64'h380E00000000000F; + z = 64'h8000000000000000; + ans = 64'hB7F8CEDF13833ECA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"531109\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h4FC000000080003F; + ans = 64'h4FC000000080003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"531723\n"); + end + x = 64'hBFDF80000007FFFE; + y = 64'hA1F0000004003FFE; + z = 64'h40200000000003FC; + ans = 64'h40200000000003FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"532337\n"); + end + x = 64'h2860008007FFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"532951\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h403123775A6D2DD2; + z = 64'h3CA0000000000401; + ans = 64'h3CA0000000000401; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"533565\n"); + end + x = 64'h8AD00003FFF7FFFF; + y = 64'hBFD0000000000001; + z = 64'h48C7FFFFFFFFFEFF; + ans = 64'h48C7FFFFFFFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"534179\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hC19001FFFF7FFFFE; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"534793\n"); + end + x = 64'hBDEF6966E82E31CA; + y = 64'hFFD169C9EC6EC12F; + z = 64'h3FBFFFFFFFFFFAFE; + ans = 64'h7DD117D6BB26D34D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"535407\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"536021\n"); + end + x = 64'hB7FE475C439E7B31; + y = 64'h40AFFFE000000003; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"536635\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFE0000000000001; + z = 64'hC0B00000007FEFFF; + ans = 64'hC0B00000007FEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"537249\n"); + end + x = 64'hC1DFFFFFF0000008; + y = 64'hBFCFFFDFFFFFFFF7; + z = 64'h3F9FEFFFFFFFFFFF; + ans = 64'h41BFFFDFF0080BFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"537863\n"); + end + x = 64'h3FC03FFFFEFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hC000000000000001; + ans = 64'hC00103FFFFF00001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"538477\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hC3EFBFFFFFFFDFFE; + z = 64'h413003FFEFFFFFFF; + ans = 64'h413003FFEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"539091\n"); + end + x = 64'hBCAFFFFFFF7FFF7F; + y = 64'hBFF0000000000000; + z = 64'hC01FFFFF80000400; + ans = 64'hC01FFFFF80000400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"539705\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBD0FFFEFFFFFC000; + z = 64'h3CA0000000000001; + ans = 64'h3CA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"540319\n"); + end + x = 64'hBFB0807FFFFFFFFF; + y = 64'h1FE000000003FC00; + z = 64'h3FBCE60789BFE91F; + ans = 64'h3FBCE60789BFE91F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"540933\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"541547\n"); + end + x = 64'h40D000201FFFFFFF; + y = 64'hC050000800010000; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"542161\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hC000000000000000; + z = 64'hC027B5C169FB9BF9; + ans = 64'hC027B5C169FB9BF9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"542775\n"); + end + x = 64'h3FF000001FFFFFFB; + y = 64'h7FFFFFFFFBFFFDFF; + z = 64'h7FF00001FBFFFFFF; + ans = 64'h7FFFFFFFFBFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"543389\n"); + end + x = 64'h4020001FFFFFFFBF; + y = 64'hC000000000000001; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hC032001FFFFFFFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"544003\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hC01FFFFFFE000001; + z = 64'hB806F34352FD18A5; + ans = 64'hB806F34352FD18A5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"544617\n"); + end + x = 64'hC02000003FFFBFFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBFE00001000003FE; + ans = 64'h403F800077FF7FDC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"545231\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h357FFFFFEFFFFFFC; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h001FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"545845\n"); + end + x = 64'hFFDEFFFFFFFFEFFE; + y = 64'h37FFFFF7FFFFFF80; + z = 64'h41DFFFFBFFFE0000; + ans = 64'hF7EEFFF83FFFEF82; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"546459\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hC010000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"547073\n"); + end + x = 64'h41FDFFABFA74E0B2; + y = 64'hBFDC6DD0BA79DD66; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFF95655BD7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"547687\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hB81FFFFFFFF77FFE; + ans = 64'hB81FFFFFFFF77FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"548301\n"); + end + x = 64'h3FB0107FFFFFFFFF; + y = 64'h80100FFFFFFFFFDE; + z = 64'hC3E0100010000000; + ans = 64'hC3E0100010000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"548915\n"); + end + x = 64'hC3FFFFE00000003E; + y = 64'hC340000000000000; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h474FFFE00000003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"549529\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h3FFFFFEFF0000000; + z = 64'hFFEF80FFFFFFFFFF; + ans = 64'hFFEF80FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"550143\n"); + end + x = 64'h43C0660CA00BB7AA; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h3ED00000FF7FFFFF; + ans = 64'hC720660CA00BB7A9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"550757\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h3FDDFBFFFFFFFFFF; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h001EFDFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"551371\n"); + end + x = 64'hBA57FFFFFFFFFBFF; + y = 64'h3FCED58246AC34ED; + z = 64'h380B7EF6003637E4; + ans = 64'hBA372021B4FDB3F7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"551985\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hFFE0000000000000; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"552599\n"); + end + x = 64'h43C00000000FBFFF; + y = 64'h8000043FFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"553213\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hC1C3414AF94B6C96; + ans = 64'hC1C3414AFD4B6C96; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"553827\n"); + end + x = 64'h3E0FFFFFF800000E; + y = 64'hC00FFFFF7FFFFFFF; + z = 64'h37EFFFFFFFF83FFF; + ans = 64'hBE2FFFFF7800002D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"554441\n"); + end + x = 64'h0020000000000240; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hBFE0000000000000; + ans = 64'hC02100000000023F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"555055\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFF00800000FFFFE; + z = 64'hBFBFFFFF7FFDFFFF; + ans = 64'hBFBFFFFF7FFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"555669\n"); + end + x = 64'hBFEFFEFFFFFF0000; + y = 64'hFFF0000000000001; + z = 64'hBFD0010001FFFFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"556283\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFE942E0EAAF09E3; + z = 64'h0000000000000000; + ans = 64'h801942E0EAAF09E1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"556897\n"); + end + x = 64'h43420003FFFFFFFF; + y = 64'hC06000FFFFFFFFF7; + z = 64'hFFF0000201FFFFFF; + ans = 64'hFFF8000201FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"557511\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h8010000000000000; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"558125\n"); + end + x = 64'hBF80007FFFFFFFBF; + y = 64'hC340000000017FFE; + z = 64'h4010000000000001; + ans = 64'h42D00080000180C9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"558739\n"); end x = 64'h3CA0000000000000; - y = 64'hC010000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000003; + y = 64'h0000000000000001; + z = 64'h000E8D6AC606E59D; + ans = 64'h000E8D6AC606E59D; rn = 1; rz = 0; rm = 0; @@ -14419,12 +42854,4477 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"616283\n"); + $fwrite(fp,"559353\n"); end - x = 64'h3CAF8000001FFFFF; - y = 64'hC340000000000000; - z = 64'h3FDFFFFFDFFEFFFF; - ans = 64'hBFF7800008203FFF; + x = 64'h403FFFFFFFFFFF76; + y = 64'hB7EFFFF00000007F; + z = 64'hC80846C2B939D9A3; + ans = 64'hC80846C2B939D9A3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"559967\n"); + end + x = 64'hB7F0040001FFFFFE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"560581\n"); + end + x = 64'h3CA0000000000000; + y = 64'hA2DD81347EA0D30C; + z = 64'hBE9000000007FFFB; + ans = 64'hBE9000000007FFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"561195\n"); + end + x = 64'h3FD4FEF9A261B85F; + y = 64'h0010000000000000; + z = 64'hC1FFFFEFFFFFFFF6; + ans = 64'hC1FFFFEFFFFFFFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"561809\n"); + end + x = 64'h3CA0000000000000; + y = 64'hC3DFFFFFFFFFFFFE; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"562423\n"); + end + x = 64'hC3F007F000000000; + y = 64'hA9AFFFFDFFFF7FFF; + z = 64'h47EFFF0010000000; + ans = 64'h47EFFF0010000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"563037\n"); + end + x = 64'h3CA0000000000000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h8000000000000001; + ans = 64'h8000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"563651\n"); + end + x = 64'h403FFFFF8007FFFF; + y = 64'hC1D000001FFFFFDF; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'hC21FFFFFBFF7FEBD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"564265\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3CA0000000000000; + z = 64'h4E60000001FFFF7F; + ans = 64'h4E60000001FFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"564879\n"); + end + x = 64'h37F000000037FFFE; + y = 64'h3CAFFFC000000008; + z = 64'hCC40000800003FFE; + ans = 64'hCC40000800003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"565493\n"); + end + x = 64'h001FFFF7FFFDFFFF; + y = 64'h3CA0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"566107\n"); + end + x = 64'h3CA0000000000000; + y = 64'hBF3FF7FFFFFEFFFF; + z = 64'h33DFFFFFF00003FE; + ans = 64'hBBEFF7FFFFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"566721\n"); + end + x = 64'hFFDFFF7FFFFFFDFF; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hC3D0000000000780; + ans = 64'hFC9FFF7FFFFFFDFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"567335\n"); + end + x = 64'h3CA0000000000000; + y = 64'hC02B75AA8C7CE7CF; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"567949\n"); + end + x = 64'h3DAA778B91CB7508; + y = 64'h41DDE00000000000; + z = 64'hA5A5E0EEE55BDC4F; + ans = 64'h3F98B59B4D1CF242; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"568563\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3FD0000000000001; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"569177\n"); + end + x = 64'hC0B2B61F5E89F40A; + y = 64'h3FE0001FFFFFFDFF; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'hC0A2B244CAC8AEC6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"569791\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hC1E00000000010FF; + ans = 64'hC1E00000000010FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"570405\n"); + end + x = 64'hBEDBFF0000000000; + y = 64'h41CFFFFFFFFFFF7F; + z = 64'hC80000000FFFFFEE; + ans = 64'hC80000000FFFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"571019\n"); + end + x = 64'hC1F000000401FFFE; + y = 64'h3FE0000000000000; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hC1E000000401FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"571633\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3FDFFFAFFFFFFFFF; + z = 64'h802FA574C852AFD8; + ans = 64'h3C8FFFAFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"572247\n"); + end + x = 64'h3FD0010000020000; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3A4FFEFFFFFDFFFE; + ans = 64'h3FD001000001FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"572861\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3FD04001FFFFFFFF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"573475\n"); + end + x = 64'hC1D0000007FFFFBE; + y = 64'h41A03FFFF0000000; + z = 64'h41CFFFFFFC000100; + ans = 64'hC3803FFFF61FFFB5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"574089\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3FF0000000000000; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"574703\n"); + end + x = 64'h7FD000000000400F; + y = 64'hFD5FFFDFFE000000; + z = 64'h3FF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"575317\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC34FFFFFFDFFFFFD; + ans = 64'hC34FFFFFFDFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"575931\n"); + end + x = 64'hB60FF7FFFF7FFFFF; + y = 64'h3F0F0000000007FF; + z = 64'h40101FFFDFFFFFFF; + ans = 64'h40101FFFDFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"576545\n"); + end + x = 64'hC3EFFFFFFFF7FBFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h8010000000000000; + ans = 64'hC3FFFFFFFFF7FBFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"577159\n"); + end + x = 64'h3CA0000000000000; + y = 64'hAC9FFFFFFFF80000; + z = 64'h40EFFFFFFFFFF77F; + ans = 64'h40EFFFFFFFFFF77F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"577773\n"); + end + x = 64'h07B00000007FFFFE; + y = 64'h4000000000000001; + z = 64'h3B20000000FEFFFE; + ans = 64'h3B20000000FEFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"578387\n"); + end + x = 64'h3CA0000000000000; + y = 64'h002FC000000000FF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"579001\n"); + end + x = 64'h3CCFF7FFFFFBFFFF; + y = 64'hBA90000100000080; + z = 64'h41E00000007FF7FF; + ans = 64'h41E00000007FF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"579615\n"); + end + x = 64'h3CA0000000000000; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"580229\n"); + end + x = 64'hBFCFFFFFFFF3FFFF; + y = 64'h40100000000100FF; + z = 64'h3FE0000000000001; + ans = 64'hBFDFFFFFFFEC03F8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"580843\n"); + end + x = 64'h3CA0000000000000; + y = 64'h4010000000000000; + z = 64'h407FFFFC1FFFFFFE; + ans = 64'h407FFFFC1FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"581457\n"); + end + x = 64'h43C047F600C3F7AA; + y = 64'h3732487BBFBF6EAC; + z = 64'hBFFFFFFFFFFFFDFB; + ans = 64'hBFFFFFFFFFFFFDFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"582071\n"); + end + x = 64'hFFF0080000001FFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h8000000000000001; + ans = 64'hFFF8080000001FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"582685\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3CAE2400053CB0F9; + z = 64'hBF8FFFFFFFFDDFFE; + ans = 64'hBF8FFFFFFFFDDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"583299\n"); + end + x = 64'hC00FE00000000FFF; + y = 64'h4340000000000000; + z = 64'hBFEBFFC000000000; + ans = 64'hC35FE00000000FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"583913\n"); + end + x = 64'h3CA0000000000000; + y = 64'hC0800003FFF80000; + z = 64'hC010000000000001; + ans = 64'hC010000000000041; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"584527\n"); + end + x = 64'hBFBFFFFFFFDFFFFE; + y = 64'h3FD01000001FFFFF; + z = 64'hBF9FFFFFFF803FFE; + ans = 64'hBFB007FFFFE807FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"585141\n"); + end + x = 64'h3CA0000000000000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h4340000000000001; + ans = 64'h4340000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"585755\n"); + end + x = 64'h47BFFFFFFFC00800; + y = 64'hC0500007FFFFBFFF; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'hC8200007FFDFC3EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"586369\n"); + end + x = 64'h3CA0000000000000; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC019CAB46F8C90A7; + ans = 64'hC011CAB46F8C90A8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"586983\n"); + end + x = 64'h8020200000000080; + y = 64'h4C9FE00000010000; + z = 64'hBFE000013FFFFFFF; + ans = 64'hBFE000013FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"587597\n"); + end + x = 64'h43D0000000007BFF; + y = 64'h7FE0000000000001; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"588211\n"); + end + x = 64'h3CA0000000000000; + y = 64'hB09002000000003E; + z = 64'h37F002000000001F; + ans = 64'h37F002000000001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"588825\n"); + end + x = 64'h43CFFFFC00400000; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h380FFFFFFFFFFBFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"589439\n"); + end + x = 64'h3CA0000000000000; + y = 64'h41EBFF0000000000; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFC801FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"590053\n"); + end + x = 64'h400F800FFFFFFFFF; + y = 64'hA991FFFFFFC00000; + z = 64'hC15DFFFFFFFDFFFE; + ans = 64'hC15DFFFFFFFDFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"590667\n"); + end + x = 64'h3CA0000000000000; + y = 64'h7FF0000000000001; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"591281\n"); + end + x = 64'hBCAC000003FFFFFF; + y = 64'hC3C00080000003FF; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h407C00E0040026FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"591895\n"); + end + x = 64'h3CA0000000000000; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h4103E839DCCFFAEF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"592509\n"); + end + x = 64'hAEA03FFFFFFFFFFD; + y = 64'h800FFFFFFFF7BFFF; + z = 64'h801000007FFFFE00; + ans = 64'h801000007FFFFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"593123\n"); + end + x = 64'h43CFFFFE0001FFFF; + y = 64'h8000000000000000; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"593737\n"); + end + x = 64'h3CA0000000000000; + y = 64'hC000002000000FFF; + z = 64'hB37EFDFFFFFFFFFF; + ans = 64'hBCB0002000000FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"594351\n"); + end + x = 64'h47EFC142A7AA9FC5; + y = 64'h8000000000000001; + z = 64'hBFA36F59B827AA2E; + ans = 64'hBFA36F59B827AA2E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"594965\n"); + end + x = 64'h3CA0000000000000; + y = 64'hBFC0FFFFFFFFFFEF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"595579\n"); + end + x = 64'h3CAFFBFFFFFFFF7F; + y = 64'h7FFFFC0000000008; + z = 64'hC1CFFFC0003FFFFE; + ans = 64'h7FFFFC0000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"596193\n"); + end + x = 64'h3CA0000000000000; + y = 64'h8010000000000000; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"596807\n"); + end + x = 64'h37FFFFFFFFDFFC00; + y = 64'h400F7FFFFFFF7FFF; + z = 64'h3CA0000000000000; + ans = 64'h3CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"597421\n"); + end + x = 64'h3CA0000000000000; + y = 64'h8010000000000001; + z = 64'hC1A000000000080F; + ans = 64'hC1A000000000080F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"598035\n"); + end + x = 64'h3FA0000003FFFFEE; + y = 64'h3FB8B9A055DED013; + z = 64'hBC0FFFFFF0020000; + ans = 64'h3F68B9A05C0D380C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"598649\n"); + end + x = 64'hC03FBFFFFFFFF800; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"599263\n"); + end + x = 64'h3CA0000000000000; + y = 64'hC0B87E66EFF0F1FE; + z = 64'hC3E000FFFFFEFFFF; + ans = 64'hC3E000FFFFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"599877\n"); + end + x = 64'h001400000000001F; + y = 64'hBCA0000000000000; + z = 64'hDA2B647026EEBA96; + ans = 64'hDA2B647026EEBA96; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"600491\n"); + end + x = 64'h3CA0000000000000; + y = 64'h1F30403FFFFFFFFF; + z = 64'hBFF0000000000000; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"601105\n"); + end + x = 64'hC1C5EEED585AABCE; + y = 64'h400FFFFFF77FFFFE; + z = 64'h480FF08000000000; + ans = 64'h480FF08000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"601719\n"); + end + x = 64'h3CA0000000000000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"602333\n"); + end + x = 64'h3B4B2B5E46FAE16F; + y = 64'hC1EC0007FFFFFFFF; + z = 64'h0010000000000001; + ans = 64'hBD47C5F948F316FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"602947\n"); + end + x = 64'h3CA0000000000000; + y = 64'hBFD0000000000000; + z = 64'h3E90D05E2957F142; + ans = 64'h3E90D05E294FF142; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"603561\n"); + end + x = 64'hBFDF80003FFFFFFF; + y = 64'hBFB003FFFEFFFFFF; + z = 64'h3CAFFE0000000200; + ans = 64'h3F9F87E03E180039; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"604175\n"); + end + x = 64'hB7EFFFFFFE00000F; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"604789\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3F90000080FFFFFE; + z = 64'hC03000000010007E; + ans = 64'hC03000000010007E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"605403\n"); + end + x = 64'hB805AF0434902F3C; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h478B9FDB62B52236; + ans = 64'h478B9FDB62B52236; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"606017\n"); + end + x = 64'h3CA0000000000000; + y = 64'h402E00001FFFFFFF; + z = 64'hBFE0000000000001; + ans = 64'hBFDFFFFFFFFFFFE4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"606631\n"); + end + x = 64'hBFCFFFFF6FFFFFFE; + y = 64'h4052E8AF709A9CA0; + z = 64'hC17003FFFFFFFFE0; + ans = 64'hC17004012E8AF198; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"607245\n"); + end + x = 64'h3CA0000000000000; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"607859\n"); + end + x = 64'h43443177992F047A; + y = 64'hBFCD6E643DF27728; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hC322927DAF9E39A7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"608473\n"); + end + x = 64'h3CA0000000000000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBFFFFF7FFFFFE000; + ans = 64'hBFFFFF7FFFFFE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"609087\n"); + end + x = 64'hFFDF8000000003FE; + y = 64'h7FE0000000040200; + z = 64'hC1EFFE0000000FFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"609701\n"); + end + x = 64'h47DF0FB4968EC67D; + y = 64'hBFF0000000000001; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'hC7DF0FB4968EC67F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"610315\n"); + end + x = 64'h3CA0000000000000; + y = 64'h40C0040004000000; + z = 64'h40071DA282D7133B; + ans = 64'h40071DA282D71B3D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"610929\n"); + end + x = 64'h801FFFFFFFFFBFEF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hC80FEFFFEFFFFFFF; + ans = 64'hC80FEFFFEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"611543\n"); + end + x = 64'h3CA0000000000000; + y = 64'h434FFFFFFEFFFDFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h3FF7FFFFFEFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"612157\n"); + end + x = 64'hBF90000FFFFFFFFF; + y = 64'hBF13C4AABD3B8972; + z = 64'h802FFFE0007FFFFF; + ans = 64'h3EB3C4BE81E646AC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"612771\n"); + end + x = 64'h3CA0000000000000; + y = 64'hC000000000000001; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"613385\n"); + end + x = 64'hA333A1B8F786C499; + y = 64'h3E6FFFFF007FFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"613999\n"); + end + x = 64'h3CA0000000000000; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h43F001FFC0000000; + ans = 64'h43F001FFC0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"614613\n"); + end + x = 64'hFFD0809EC4FE2D71; + y = 64'hBFA4C050535BFCCB; + z = 64'h4427ED571629ABB8; + ans = 64'h7F856720C08D93C5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"615227\n"); + end + x = 64'h47FFFFFFFFFF8400; + y = 64'hC010000000000000; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'hC81FFFFFFFFF8400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"615841\n"); + end + x = 64'h3CA0000000000000; + y = 64'hC3FFBFFFFFFFFFFF; + z = 64'h419FC00000000040; + ans = 64'h419FBFC080000040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"616455\n"); + end + x = 64'h3FC412D60269F292; + y = 64'hC010000000000001; + z = 64'hC1E476A2F395D532; + ans = 64'hC1E476A2F3A9E808; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"617069\n"); + end + x = 64'h3CA0000000000000; + y = 64'hC03836C73E52BECA; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCEA36C73E52BECA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"617683\n"); + end + x = 64'hC1FFFEFFFFFFFF00; + y = 64'hD1540000000FFFFF; + z = 64'hC1FF6A7F749999AB; + ans = 64'h5363FF60000FFEDF; rn = 1; rz = 0; rm = 0; @@ -14468,57 +47368,10 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"618297\n"); end - x = 64'hC3FFFFFFFFF007FE; - y = 64'hC1C650B9AA81629A; - z = 64'h381000000000000E; - ans = 64'h45D650B9AA763FD0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"620311\n"); - end x = 64'h3CA0000000000000; - y = 64'hFFE0000000000001; - z = 64'h4340000000000000; - ans = 64'hFC90000000000001; + y = 64'hC340000000000000; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'hBFE0000000000001; rn = 1; rz = 0; rm = 0; @@ -14560,1656 +47413,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"622325\n"); + $fwrite(fp,"618911\n"); end - x = 64'hBE01000000100000; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hBFD79D33FB7309A1; - ans = 64'h7E010000000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"624339\n"); - end - x = 64'hC01000007FFFFFDE; - y = 64'h3811953D5A433174; - z = 64'h3E7FFDFFFF7FFFFF; - ans = 64'h3E7FFDFFFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"626353\n"); - end - x = 64'h3CA0000000000001; - y = 64'h0000000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"628367\n"); - end - x = 64'h381FF7FF7FFFFFFF; - y = 64'h000FFFFFFFFFFFFE; - z = 64'h480200000000001F; - ans = 64'h480200000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"630381\n"); - end - x = 64'h3FB0FFFFFFFFFFFF; - y = 64'h407000000FFFFFBF; - z = 64'hC0F00000000800FE; - ans = 64'hC0EFFDE0000DE1FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"632395\n"); - end - x = 64'h3CA0000000000001; - y = 64'h3CA0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"634409\n"); - end - x = 64'hB7FFFF7FFFBFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'hC34D14F7E73ECCFF; - ans = 64'hC34D14F7E73ECCFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"636423\n"); - end - x = 64'hC050000003DFFFFF; - y = 64'hBD6000000004000F; - z = 64'h3FEF7FFFFFFFFFDE; - ans = 64'h3FEF80000003FFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"638437\n"); - end - x = 64'h3CA0000000000001; - y = 64'h3FE0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"640451\n"); - end - x = 64'h3FF00101FFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hC3FFFFFF00007FFE; - ans = 64'hC3FFFFFF00007FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"642465\n"); - end - x = 64'h40154B404B0501A2; - y = 64'h380000000003FFFE; - z = 64'hBFEFFEFFFDFFFFFF; - ans = 64'hBFEFFEFFFDFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"644479\n"); - end - x = 64'h3CA0000000000001; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"646493\n"); - end - x = 64'h58F0000100003FFF; - y = 64'h400FFFFFFFFFFFFF; - z = 64'hB81FFF8000000004; - ans = 64'h5910000100003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"648507\n"); - end - x = 64'h001EFF8000000000; - y = 64'h3801AD261B713620; - z = 64'hBEEFFFEFFF000000; - ans = 64'hBEEFFFEFFF000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"650521\n"); - end - x = 64'h3CA0000000000001; - y = 64'h401FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"652535\n"); - end - x = 64'hC5B00000000FFFFD; - y = 64'h434FFFFFFFFFFFFF; - z = 64'h47DDFFFFFFFFDFFF; - ans = 64'hC90FFFFC401FFFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"654549\n"); - end - x = 64'hC7FFD288F3EB4DC5; - y = 64'h480FFFFFFFE00001; - z = 64'h705E000000000000; - ans = 64'h705E000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"656563\n"); - end - x = 64'h3CA0000000000001; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"658577\n"); - end - x = 64'h849FFFFF7FFBFFFF; - y = 64'h7FF0000000000001; - z = 64'h507FFFBE00000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"660591\n"); - end - x = 64'hFFE0000000038000; - y = 64'h3C100007FFFFFFFF; - z = 64'h3FEFFE0003FFFFFE; - ans = 64'hFC00000800038001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"662605\n"); - end - x = 64'h3CA0000000000001; - y = 64'h800FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"664619\n"); - end - x = 64'hBFB83950C7648672; - y = 64'h8010000000000001; - z = 64'hFEDFFFFC003FFFFF; - ans = 64'hFEDFFFFC003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"666633\n"); - end - x = 64'hC3F0800400000000; - y = 64'h3C8657726912D3F9; - z = 64'h800FFFFFFF9FFFFF; - ans = 64'hC0870A33923804DD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"668647\n"); - end - x = 64'h3CA0000000000001; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"670661\n"); - end - x = 64'hC015256E6A7C8C32; - y = 64'hBFD0000000000000; - z = 64'hB7FFFFE00FFFFFFE; - ans = 64'h3FF5256E6A7C8C32; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"672675\n"); - end - x = 64'hC15001FFFFFEFFFF; - y = 64'h0010000C00000000; - z = 64'h58700000037FFFFE; - ans = 64'h58700000037FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"674689\n"); - end - x = 64'h3CA0000000000001; - y = 64'hBFE0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"676703\n"); - end - x = 64'h32601FF7FFFFFFFE; - y = 64'hBFF0000000000000; - z = 64'h58800008000001FE; - ans = 64'h58800008000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"678717\n"); - end - x = 64'h4073FFFFFFBFFFFF; - y = 64'h4FF96CDBA635E070; - z = 64'h801000807FFFFFFF; - ans = 64'h507FC8128F5DA51C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"680731\n"); - end - x = 64'h3CA0000000000001; - y = 64'hC000000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCC0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"682745\n"); - end - x = 64'hC2E44ABF8AECE4F4; - y = 64'hC010000000000000; - z = 64'h3A000FFE00000000; - ans = 64'h43044ABF8AECE4F4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"684759\n"); - end - x = 64'h3FBFFFFDFFFFFFDF; - y = 64'h409FFFDC00000000; - z = 64'hB13000FFEFFFFFFE; - ans = 64'h406FFFDA00023FDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"686773\n"); - end - x = 64'h3CA0000000000001; - y = 64'hC340000000000001; - z = 64'h3FF0000000000001; - ans = 64'hBCB0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"688787\n"); - end - x = 64'h4027FFFFFF7FFFFE; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h3FF5535DAB32E04B; - ans = 64'hC387FFFFFF7FFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"690801\n"); - end - x = 64'h3FB0000001000004; - y = 64'h8010007EFFFFFFFE; - z = 64'h3FBFFFFBFFFFE000; - ans = 64'h3FBFFFFBFFFFE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"692815\n"); - end - x = 64'h3CA0000000000001; - y = 64'hFFF0000000000000; - z = 64'hC340000000000000; + x = 64'h3FD78110F038153D; + y = 64'h682FFFE000008000; + z = 64'hFFF0000000000000; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -16252,12 +47460,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"694829\n"); + $fwrite(fp,"619525\n"); end - x = 64'hC1DC9FA56189CACB; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h801FFFFF00FFFFFF; - ans = 64'hFFFFFFFFFFFFFFFE; + x = 64'h3CA0000000000000; + y = 64'hC340000000000001; + z = 64'hC2BFFFFFFFFC07FE; + ans = 64'hC2BFFFFFFFFC08FE; rn = 1; rz = 0; rm = 0; @@ -16299,12 +47507,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"696843\n"); + $fwrite(fp,"620139\n"); end - x = 64'hB80AC4A58221FD00; - y = 64'hB80FFFFFFE000004; - z = 64'h401FFFFFFFFFE7FF; - ans = 64'h401FFFFFFFFFE7FF; + x = 64'h410002007FFFFFFE; + y = 64'h41801EFFFFFFFFFF; + z = 64'hC3FCB59067D08B65; + ans = 64'hC3FCB590274C79E1; rn = 1; rz = 0; rm = 0; @@ -16346,12 +47554,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"698857\n"); + $fwrite(fp,"620753\n"); end - x = 64'h3CAFFFFFFFFFFFFF; - y = 64'h0010000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + x = 64'hC3DFFFFFEFFFFFF6; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h4000000000000000; + ans = 64'h473FFFFFEFFFFFF4; rn = 1; rz = 0; rm = 0; @@ -16393,12 +47601,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"700871\n"); + $fwrite(fp,"621367\n"); end - x = 64'hBCA000008003FFFF; - y = 64'h001FFFFFFFFFFFFE; - z = 64'hB8C000001FFBFFFF; - ans = 64'hB8C000001FFBFFFF; + x = 64'h3CA0000000000000; + y = 64'hBE9FFFFFFC03FFFF; + z = 64'h7FF00002000003FF; + ans = 64'h7FF80002000003FF; rn = 1; rz = 0; rm = 0; @@ -16440,1328 +47648,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"702885\n"); + $fwrite(fp,"621981\n"); end - x = 64'h40AFFFFFFFBEFFFF; - y = 64'hC1F5BB80746EB9E1; - z = 64'h7FD7FFFFFBFFFFFE; - ans = 64'h7FD7FFFFFBFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"704899\n"); - end - x = 64'h3CAFFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CB3FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"706913\n"); - end - x = 64'hC3E02000000FFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'hC0CFFFFF00008000; - ans = 64'hC3D020000010000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"708927\n"); - end - x = 64'h3B1001FFFFF7FFFF; - y = 64'hC3EC47DBDB9FC9E2; - z = 64'hC19F80000000001F; - ans = 64'hC19F800000000E45; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"710941\n"); - end - x = 64'h3CAFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"712955\n"); - end - x = 64'h43CFFFFFFFFF3FFF; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'hBFCBFECEE81F8C27; - ans = 64'h43DFFFFFFFFF3FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"714969\n"); - end - x = 64'h3FC79F966F93CE1B; - y = 64'h403FFFEFEFFFFFFE; - z = 64'hB7F15A82F49DD625; - ans = 64'h40179F8A93F8CB18; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"716983\n"); - end - x = 64'h3CAFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"718997\n"); - end - x = 64'hC1DFFFFFEFFFDFFF; - y = 64'h4010000000000001; - z = 64'h43E0004001000000; - ans = 64'h43E0004000C00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"721011\n"); - end - x = 64'h3FDF0E80E74103A1; - y = 64'hFFF000000803FFFE; - z = 64'hC0D7255CF31DB9E1; - ans = 64'hFFF800000803FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"723025\n"); - end - x = 64'h3CAFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"725039\n"); - end - x = 64'hC063FFFFBFFFFFFE; - y = 64'h7FE0000000000001; - z = 64'h7FFFFFFFF80001FE; - ans = 64'h7FFFFFFFF80001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"727053\n"); - end - x = 64'h3F0FFFFFEBFFFFFE; - y = 64'h7FD0000000404000; - z = 64'h7FD0000010200000; - ans = 64'h7FD00040101FD901; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"729067\n"); - end - x = 64'h3CAFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"731081\n"); - end - x = 64'h403AB1833690B538; - y = 64'h8000000000000001; - z = 64'h41F12C4895209B98; - ans = 64'h41F12C4895209B98; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"733095\n"); - end - x = 64'h8000000110000000; - y = 64'hC2F0000080200000; - z = 64'h400FBFFFFFFFDFFF; - ans = 64'h400FBFFFFFFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"735109\n"); - end - x = 64'h3CAFFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"737123\n"); - end - x = 64'h38C000FFFFFFFFF6; - y = 64'hBCA0000000000000; - z = 64'h37E76291995D8252; - ans = 64'h37E76291995D6250; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"739137\n"); - end - x = 64'hFFE03FFFFBFFFFFF; - y = 64'hBCD3CB8B7F735D5B; - z = 64'hC3E03FFFEFFFFFFF; - ans = 64'h7CC41AB9A87E47EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"741151\n"); - end - x = 64'h3CAFFFFFFFFFFFFF; - y = 64'hBFD0000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"743165\n"); - end - x = 64'h37FFC3CD8026EDA0; - y = 64'hBFE0000000000000; - z = 64'hBEAB43550AFC66D5; - ans = 64'hBEAB43550AFC66D5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"745179\n"); - end - x = 64'h3CAF0000007FFFFF; - y = 64'h43C3BA241E9C39CF; - z = 64'h43EFEFFDFFFFFFFF; - ans = 64'h43EFEFFDFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"747193\n"); - end - x = 64'h3CAFFFFFFFFFFFFF; - y = 64'hBFF0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"749207\n"); - end - x = 64'hBFAFFFFDFFFFFEFF; - y = 64'hC000000000000000; - z = 64'h3F4000080000001F; - ans = 64'h3FC00FFF07FFFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"751221\n"); - end - x = 64'h00205BF15AD11CA4; - y = 64'hC051FFFFFFBFFFFE; - z = 64'hBFBFDFFFFFFFDFFE; - ans = 64'hBFBFDFFFFFFFDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"753235\n"); - end - x = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC010000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hBCC8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"755249\n"); - end - x = 64'h3FD000000FBFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h3FE00000FFFFFEFE; - ans = 64'hBFF7FFFF9F80007D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"757263\n"); - end - x = 64'h412D4A1BE5D5E7E2; - y = 64'hCD600000006FFFFF; - z = 64'h47EFFFFFFF7FFFDF; - ans = 64'hCE9D4A1BE6A2EEA3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"759277\n"); - end - x = 64'h3CAFFFFFFFFFFFFF; + x = 64'h41F0000040000FFF; y = 64'hFFE0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hFC9FFFFFFFFFFFFF; + z = 64'h37E00000FFDFFFFE; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -17803,12 +47695,106 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"761291\n"); + $fwrite(fp,"622595\n"); end - x = 64'hBEC0004000004000; + x = 64'h3CA0000000000000; + y = 64'hECB7B942F9055E17; + z = 64'hBCA0000000000000; + ans = 64'hE967B942F9055E17; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"623209\n"); + end + x = 64'hBFBFFFFFBFFFFBFE; + y = 64'h403FF80000000FFF; + z = 64'hB7EFFC0000000800; + ans = 64'hC00FF7FFC0100BFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"623823\n"); + end + x = 64'h3CA0000000000000; y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hBFFC821044378807; - ans = 64'h7EC0004000003FFF; + z = 64'h3FD0000000000000; + ans = 64'hFC9FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -17850,12 +47836,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"763305\n"); + $fwrite(fp,"624437\n"); end - x = 64'h8C0FFEFFFFFFFE00; - y = 64'h4360000000FFFFEF; - z = 64'h43F000003FFFFE00; - ans = 64'h43F000003FFFFE00; + x = 64'h3CAFFFFFFFFFBC00; + y = 64'hC0DFFF7FFFFFFFF7; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; rn = 1; rz = 0; rm = 0; @@ -17897,12 +47883,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"765319\n"); + $fwrite(fp,"625051\n"); end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'h0000000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + x = 64'h3CA0000000000000; + y = 64'hFFF0000000000000; + z = 64'h3D696CE5B4272424; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -17944,12 +47930,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"767333\n"); + $fwrite(fp,"625665\n"); end - x = 64'h3FCFFFFF800003FE; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hBFD0000023FFFFFE; - ans = 64'hBFD0000023FFFFFE; + x = 64'hB789E111956BE9EB; + y = 64'hFA7FFDFFFFFBFFFF; + z = 64'h37B0085F71B84DC0; + ans = 64'h7219DF73844F5709; rn = 1; rz = 0; rm = 0; @@ -17991,12 +47977,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"769347\n"); + $fwrite(fp,"626279\n"); end - x = 64'hBFD000080000000F; - y = 64'hB7E1FBFFFFFFFFFF; - z = 64'hB800200000003FFE; - ans = 64'hB7FE007EE0407FFA; + x = 64'hC007C6480B50CE31; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -18038,11 +48024,58 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"771361\n"); + $fwrite(fp,"626893\n"); end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; + x = 64'h3CA0000000000000; + y = 64'h40E0001FF7FFFFFF; + z = 64'hB7FD3409DC18DB9B; + ans = 64'h3D90001FF7FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"627507\n"); + end + x = 64'hB6B00000000023FF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h381FFFFFFE000000; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -18085,12 +48118,623 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"773375\n"); + $fwrite(fp,"628121\n"); end - x = 64'h40192DFAA3A08E50; + x = 64'h3CA0000000000001; + y = 64'hBFCC0DA6851DE8E0; + z = 64'h8010000000000001; + ans = 64'hBC7C0DA6851DE8E2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"628735\n"); + end + x = 64'h2CFFFFFFBBFFFFFF; + y = 64'hC03FFFFFFFFDFFFB; + z = 64'hC0E07FFF00000000; + ans = 64'hC0E07FFF00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"629349\n"); + end + x = 64'h3CA0000000000001; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3CA0000000000001; + ans = 64'h3CA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"629963\n"); + end + x = 64'hC281AA5C3F9C8D6D; + y = 64'h480FFFFFC007FFFE; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hCAA1AA5C1C4C3F84; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"630577\n"); + end + x = 64'h3CA0000000000001; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h001E0000001FFFFF; + ans = 64'h001E0000001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"631191\n"); + end + x = 64'h7FFFFFFFFFFFFF76; + y = 64'h37E4A237FD281C2D; + z = 64'h37E0004000FFFFFF; + ans = 64'h7FFFFFFFFFFFFF76; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"631805\n"); + end + x = 64'hCCDD9073C4CA0F6E; + y = 64'h0010000000000001; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"632419\n"); + end + x = 64'h3CA0000000000001; + y = 64'h4030007BFFFFFFFE; + z = 64'h00200040003FFFFE; + ans = 64'h3CE0007BFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"633033\n"); + end + x = 64'h45D001FFFFFF0000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h00240000007FFFFF; + ans = 64'h060001FFFFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"633647\n"); + end + x = 64'h3CA0000000000001; + y = 64'hB0F1000000FFFFFF; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'hADA1000001000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"634261\n"); + end + x = 64'h40C0200000000003; + y = 64'h3E9173C34A679357; + z = 64'hFFF1FFF7FFFFFFFE; + ans = 64'hFFF9FFF7FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"634875\n"); + end + x = 64'h3CA0000000000001; + y = 64'h3CA0000000000001; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h3950000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"635489\n"); + end + x = 64'hBB5FDFFFFFF7FFFE; + y = 64'h8021FEFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"636103\n"); + end + x = 64'h3CA0000000000001; y = 64'h3CAFFFFFFFFFFFFF; - z = 64'hC7E000800003FFFF; - ans = 64'hC7E000800003FFFF; + z = 64'h401FFFFFFEDFFFFF; + ans = 64'h401FFFFFFEDFFFFF; rn = 1; rz = 0; rm = 0; @@ -18132,12 +48776,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"775389\n"); + $fwrite(fp,"636717\n"); end - x = 64'hC040003FFFFBFFFE; - y = 64'hBFC00000009FFFFF; - z = 64'hB97FFFFFFFB00000; - ans = 64'h40100040009C027D; + x = 64'h402FFFFFFFFDDFFE; + y = 64'h3F8FFFFFFFFF000F; + z = 64'h406FFBFFFFDFFFFF; + ans = 64'h407001FFFFEFFF9C; rn = 1; rz = 0; rm = 0; @@ -18179,12 +48823,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"777403\n"); + $fwrite(fp,"637331\n"); end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCA0000000000001; + x = 64'h41F0060000000000; + y = 64'h3FD0000000000000; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h41D0060000200000; rn = 1; rz = 0; rm = 0; @@ -18226,12 +48870,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"779417\n"); + $fwrite(fp,"637945\n"); end - x = 64'h0020000020010000; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hC1DFFFFFF0100000; - ans = 64'hC1DFFFFFF0100000; + x = 64'h3CA0000000000001; + y = 64'hBF30004000200000; + z = 64'h16F1FFFFFFFBFFFF; + ans = 64'hBBE0004000200001; rn = 1; rz = 0; rm = 0; @@ -18273,12 +48917,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"781431\n"); + $fwrite(fp,"638559\n"); end - x = 64'hB817A3D74B06DC56; - y = 64'h5650000002000FFF; - z = 64'hBCAF83FFFFFFFFFE; - ans = 64'hCE77A3D74DFB6EE2; + x = 64'hC00FBEFFFFFFFFFF; + y = 64'h3FD0000000000001; + z = 64'hC1E1FFFFFFFFF7FE; + ans = 64'hC1E20000001FB6FE; rn = 1; rz = 0; rm = 0; @@ -18320,12 +48964,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"783445\n"); + $fwrite(fp,"639173\n"); end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000003; + x = 64'h3CA0000000000001; + y = 64'h45EE000000000010; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -18367,12 +49011,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"785459\n"); + $fwrite(fp,"639787\n"); end - x = 64'hB7EFFFFFC07FFFFF; - y = 64'h4000000000000001; - z = 64'h40028B346BBCA5BA; - ans = 64'h40028B346BBCA5BA; + x = 64'h3CAF000000010000; + y = 64'h40CD9821F2214351; + z = 64'h3FEBFFFFFFFFFE00; + ans = 64'h3FEC0000000070AE; rn = 1; rz = 0; rm = 0; @@ -18414,12 +49058,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"787473\n"); + $fwrite(fp,"640401\n"); end - x = 64'h7FDFFFFFEFFFF000; - y = 64'hB7EFFC0000FFFFFF; - z = 64'hA785F7C5BE65AEFC; - ans = 64'hF7DFFBFFF101F000; + x = 64'h3CA0000000000001; + y = 64'h3FE0000000000000; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h3C90000000000001; rn = 1; rz = 0; rm = 0; @@ -18461,12 +49105,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"789487\n"); + $fwrite(fp,"641015\n"); end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + x = 64'hC11FFFF800007FFF; + y = 64'h4342C5257254E48E; + z = 64'hC010000000000000; + ans = 64'hC472C520C10BD30D; rn = 1; rz = 0; rm = 0; @@ -18508,11 +49152,246 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"791501\n"); + $fwrite(fp,"641629\n"); end - x = 64'h7FD3FFFDFFFFFFFE; - y = 64'h4340000000000001; - z = 64'hC3DD0D539EDF571B; + x = 64'h3CA0000000000001; + y = 64'h3FE0000000000001; + z = 64'hC02F53C96958BA00; + ans = 64'hC02F53C96958BA00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"642243\n"); + end + x = 64'hC3FFFFFFFC1FFFFF; + y = 64'h480FFFFFF8008000; + z = 64'hBDE00008007FFFFF; + ans = 64'hCC1FFFFFF4208000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"642857\n"); + end + x = 64'hB8020CD4671337DF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"643471\n"); + end + x = 64'h3CA0000000000001; + y = 64'h432000000FEFFFFF; + z = 64'h43F0001BFFFFFFFF; + ans = 64'h43F0001BFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"644085\n"); + end + x = 64'hBFFDB0D21ABE9560; + y = 64'h3FF0000000000000; + z = 64'hB808F2DEE31A0781; + ans = 64'hBFFDB0D21ABE9560; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"644699\n"); + end + x = 64'h3CA0000000000001; + y = 64'h3E295BE2AB58A5F9; + z = 64'h7FF0000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -18555,12 +49434,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"793515\n"); + $fwrite(fp,"645313\n"); end - x = 64'hB4B6E07873102932; - y = 64'h434FF87FFFFFFFFF; - z = 64'h47E34D80C103EAA3; - ans = 64'h47E34D80C103EAA3; + x = 64'hFCC00000040FFFFF; + y = 64'hC3E0A8C598700473; + z = 64'hFFE000001FBFFFFF; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -18602,12 +49481,952 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"795529\n"); + $fwrite(fp,"645927\n"); end - x = 64'h3CAFFFFFFFFFFFFE; + x = 64'h3CA0000000000001; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h0000000000000000; + ans = 64'h3CB0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"646541\n"); + end + x = 64'h001FFFFFFFFFFFE2; + y = 64'hC1FFC000000000FE; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"647155\n"); + end + x = 64'h3CA0000000000001; + y = 64'h4000000000000000; + z = 64'h3FDFEFFFFC000000; + ans = 64'h3FDFEFFFFC000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"647769\n"); + end + x = 64'hC3FFFFFFEFFFFFFB; + y = 64'h80200007FFFBFFFF; + z = 64'h41D01FFFFFE00000; + ans = 64'h41D01FFFFFE00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"648383\n"); + end + x = 64'hC0300081FFFFFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h3CA0000000000001; + ans = 64'hC0500081FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"648997\n"); + end + x = 64'h3CA0000000000001; + y = 64'hBFE000000FFFDFFF; + z = 64'h3FEE60AF9E2E4B00; + ans = 64'h3FEE60AF9E2E4AFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"649611\n"); + end + x = 64'hBFDFFFFFFFCFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h002FFFFFF7FFFFFF; + ans = 64'hBFFFFFFFFFCFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"650225\n"); + end + x = 64'h3CA0000000000001; + y = 64'h61BFE01FFFFFFFFF; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"650839\n"); + end + x = 64'h44820F5D13A0271D; + y = 64'hC34FFFEFFFFBFFFF; + z = 64'hC3E0000FFFE00000; + ans = 64'hC7E20F540BEF5B61; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"651453\n"); + end + x = 64'h3CA0000000000001; + y = 64'h4010000000000001; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"652067\n"); + end + x = 64'hC01B78321869F7BE; + y = 64'hBFCFFFFFF6FFFFFF; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFD21F37BD3F5963; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"652681\n"); + end + x = 64'h3CA0000000000001; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h57A0008000000400; + ans = 64'h57A0008000000400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"653295\n"); + end + x = 64'h47F0FFFFFFFFFFFE; + y = 64'hBFCFF00000800000; + z = 64'hC0800000201FFFFF; + ans = 64'hC7D0F7800043FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"653909\n"); + end + x = 64'h000FFFFFFFFFFFF0; + y = 64'h4340000000000001; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h035FFFFFFFFFFFE4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"654523\n"); + end + x = 64'h3CA0000000000001; + y = 64'h7FD5CF6583F3D781; + z = 64'hC03FFFFFFFFBFFFE; + ans = 64'h7C85CF6583F3D782; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"655137\n"); + end + x = 64'hBFC0000004000007; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hC3CFFFDFFFBFFFFE; + ans = 64'hC3D001EFFFE07FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"655751\n"); + end + x = 64'h3CA0000000000001; + y = 64'hFE303FFFF7FFFFFF; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'hFAE03FFFF8000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"656365\n"); + end + x = 64'h4010000220000000; + y = 64'h4F1000010000000E; + z = 64'h41D0000000200FFF; + ans = 64'h4F3000032000220E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"656979\n"); + end + x = 64'h3CA0000000000001; + y = 64'h7FE0000000000000; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"657593\n"); + end + x = 64'h37E6C14F3ECC26DC; + y = 64'h000FFFFFFFF0007E; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"658207\n"); + end + x = 64'h3CA0000000000001; y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + z = 64'h4013F2A6D8BFBBDB; + ans = 64'h7CA0000000000000; rn = 1; rz = 0; rm = 0; @@ -18649,11 +50468,152 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"797543\n"); + $fwrite(fp,"658821\n"); end - x = 64'h37E000000013FFFE; + x = 64'h47F66E124896F602; + y = 64'h43FFFCFFFFFFFFFF; + z = 64'hC02C17F8E33324F9; + ans = 64'h4C066BF7F6E027DA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"659435\n"); + end + x = 64'hC696F52476AFBCC8; + y = 64'h7FF0000000000000; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"660049\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC1CFFE0000400000; + z = 64'h483FFFC00007FFFF; + ans = 64'h483FFFC00007FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"660663\n"); + end + x = 64'hC7E00002000007FF; y = 64'h7FF0000000000001; - z = 64'hC04D4D91018AB805; + z = 64'hC7EFE000003FFFFF; ans = 64'h7FF8000000000001; rn = 1; rz = 0; @@ -18696,12 +50656,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"799557\n"); + $fwrite(fp,"661277\n"); end - x = 64'hB802D62C03D44556; - y = 64'h400FFFF87FFFFFFE; - z = 64'hFFEFFFFFC00001FF; - ans = 64'hFFEFFFFFC00001FF; + x = 64'h3CA0000000000001; + y = 64'hCB5FFFFDF7FFFFFE; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'hC80FFFFDF8000000; rn = 1; rz = 0; rm = 0; @@ -18743,10 +50703,2924 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"801571\n"); + $fwrite(fp,"661891\n"); end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFF; + x = 64'hC1E00800000007FF; + y = 64'h000FFFFFFFF00020; + z = 64'hBE8FFFFFFFFFFFDA; + ans = 64'hBE8FFFFFFFFFFFDA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"662505\n"); + end + x = 64'h3CA0000000000001; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"663119\n"); + end + x = 64'h41E000FFFE000000; + y = 64'hBFF0000100000100; + z = 64'hBFE0000000000000; + ans = 64'hC1E00100FE2000E0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"663733\n"); + end + x = 64'h3CA0000000000001; + y = 64'h8000000000000001; + z = 64'h4030A513CDCFDE22; + ans = 64'h4030A513CDCFDE22; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"664347\n"); + end + x = 64'hBF90A893B7D37E1B; + y = 64'hC00460035561ED96; + z = 64'hE6CEFFFFFFFFFFFE; + ans = 64'hE6CEFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"664961\n"); + end + x = 64'h3BEFE000FFFFFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h0000000000000000; + ans = 64'h8000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"665575\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC1F6C8E803D2458C; + z = 64'h43F00000000080FE; + ans = 64'h43F00000000080FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"666189\n"); + end + x = 64'h3F6FFFF00FFFFFFF; + y = 64'h8010000000000000; + z = 64'h3F9000000000000F; + ans = 64'h3F9000000000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"666803\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC120000000200040; + z = 64'h4010000000000000; + ans = 64'h400FFFFFFFFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"667417\n"); + end + x = 64'h3FC00010000000FE; + y = 64'hBB800000000100FF; + z = 64'hC80FC00001FFFFFF; + ans = 64'hC80FC00001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"668031\n"); + end + x = 64'h3CA0000000000001; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"668645\n"); + end + x = 64'hC7EF2E0B46A61E7E; + y = 64'hBFFFFF80000007FF; + z = 64'hBFD0000000000001; + ans = 64'h47FF2D8E8E790BB0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"669259\n"); + end + x = 64'h3CA0000000000001; + y = 64'hBCA0000000000000; + z = 64'h3801FFFFFFDFFFFE; + ans = 64'hB94FFFFEE0000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"669873\n"); + end + x = 64'hFFD00000000001FF; + y = 64'h352FFF7C00000000; + z = 64'hBC7FFDF000000000; + ans = 64'hF50FFF7C000003FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"670487\n"); + end + x = 64'h37E04000000003FE; + y = 64'hBCA0000000000001; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"671101\n"); + end + x = 64'h3CA0000000000001; + y = 64'hB80D3E094BC16B46; + z = 64'hC7FC72513751EFEA; + ans = 64'hC7FC72513751EFEA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"671715\n"); + end + x = 64'h3FA0001400000000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBF23FBFFFFFFFFFE; + ans = 64'hBF23FC00000000FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"672329\n"); + end + x = 64'h3CA0000000000001; + y = 64'hB8010000007FFFFF; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"672943\n"); + end + x = 64'h7FE00000FFFFFFEE; + y = 64'hC00FFFFFFFFFFF76; + z = 64'h47E80CB0EEBCEF16; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"673557\n"); + end + x = 64'h3CA0000000000001; + y = 64'hBFD0000000000001; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"674171\n"); + end + x = 64'hC520008000020000; + y = 64'h3FBFFFFFFDFFFFFC; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC4F0007FFF01F7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"674785\n"); + end + x = 64'h3CA0000000000001; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h38113D51639121A9; + ans = 64'hBC90000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"675399\n"); + end + x = 64'hFFFFFFFBEFFFFFFE; + y = 64'hC3FF564D15AB56DC; + z = 64'h56BF000000000003; + ans = 64'hFFFFFFFBEFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"676013\n"); + end + x = 64'h4035C1F65B378519; + y = 64'hBFE0000000000000; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"676627\n"); + end + x = 64'h3CA0000000000001; + y = 64'hBA2FDFFFFFFDFFFF; + z = 64'h402FFFFFFFFFE1FF; + ans = 64'h402FFFFFFFFFE1FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"677241\n"); + end + x = 64'h401C000001FFFFFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hC34C792259BDA2BF; + ans = 64'hC34C792259BDA2C3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"677855\n"); + end + x = 64'h3CA0000000000001; + y = 64'hFFF0000000006000; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'hFFF8000000006000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"678469\n"); + end + x = 64'h47FFFFF80000007F; + y = 64'h3A1BDFDA2C46A1D6; + z = 64'h46EFFFFFFFFFE07F; + ans = 64'h46EFFFFFFFFFE07F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"679083\n"); + end + x = 64'h3CA0000000000001; + y = 64'hBFF0000000000000; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"679697\n"); + end + x = 64'h44F0000000000DFF; + y = 64'h000000007FBFFFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h03BFEFFFFF801BF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"680311\n"); + end + x = 64'h3CA0000000000001; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3FF0007FFFFFFC00; + ans = 64'h3FF0007FFFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"680925\n"); + end + x = 64'hC000000000000000; + y = 64'hC010000100001FFE; + z = 64'h405157A7B0E2BCA9; + ans = 64'h405357A7D0E2C0A9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"681539\n"); + end + x = 64'h44D400000007FFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC4E400000807FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"682153\n"); + end + x = 64'h3CA0000000000001; + y = 64'hFFF0000000001FFD; + z = 64'hC1E000080000003F; + ans = 64'hFFF8000000001FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"682767\n"); + end + x = 64'h4BD00003FFDFFFFE; + y = 64'hC000000000000001; + z = 64'hD4CFFFFFFFFFFC02; + ans = 64'hD4CFFFFFFFFFFC02; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"683381\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC19000002000007F; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFFFFFFBFFFFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"683995\n"); + end + x = 64'hBCAFFEFEFFFFFFFE; + y = 64'h41DFFFFFF800001E; + z = 64'hFFDFFFFFEFFFFF80; + ans = 64'hFFDFFFFFEFFFFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"684609\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"685223\n"); + end + x = 64'hC1EE000000000020; + y = 64'h3FD000000007BFFF; + z = 64'h8010000000000000; + ans = 64'hC1CE0000000E881E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"685837\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC010000000000001; + z = 64'h87A0100000001FFE; + ans = 64'hBCC0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"686451\n"); + end + x = 64'h4377FFFFFBFFFFFE; + y = 64'hBFDCFFFFFFFFFFFE; + z = 64'h4003FFF7FFFFFFFF; + ans = 64'hC365BFFFFC5FFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"687065\n"); + end + x = 64'h8E89B3D545ADB9EA; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"687679\n"); + end + x = 64'h3CA0000000000001; + y = 64'hBFB00000000200FF; + z = 64'hBE37FFFFFFFFFFDF; + ans = 64'hBE380000007FFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"688293\n"); + end + x = 64'h47F940B6FC43B061; + y = 64'hC340000000000000; + z = 64'hF56FFFFB7FFFFFFF; + ans = 64'hF56FFFFB7FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"688907\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC00FFFFFFFFFFF02; + z = 64'h3FE0000000000000; + ans = 64'h3FDFFFFFFFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"689521\n"); + end + x = 64'h43E0000000080007; + y = 64'h43E1000040000000; + z = 64'h381FFFFFFFFF83FE; + ans = 64'h47D1000040088008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"690135\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hBFF0000000000000; + ans = 64'hC008000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"690749\n"); + end + x = 64'hEE0000000000037F; + y = 64'h40ABFFFFF7FFFFFF; + z = 64'h8000000000000001; + ans = 64'hEEBBFFFFF800061D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"691363\n"); + end + x = 64'h3CA0000000000001; + y = 64'hFFE0000000000000; + z = 64'hC0BFFFF7FFFFFFF6; + ans = 64'hFC90000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"691977\n"); + end + x = 64'h3EB001FFFFFFFFFE; + y = 64'hBFB00010000FFFFE; + z = 64'h802A8ECA25EFF308; + ans = 64'hBE700210021001FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"692591\n"); + end + x = 64'h41600801FFFFFFFF; + y = 64'hFFE0000000000001; + z = 64'hC010000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"693205\n"); + end + x = 64'h3CA0000000000001; + y = 64'hACDFFFFFFFFF7EFF; + z = 64'h3FA0000000000200; + ans = 64'h3FA0000000000200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"693819\n"); + end + x = 64'hC7FFFFFFC00003FE; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hBFBFFFE000001FFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"694433\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC470000020000000; + z = 64'h3FD0000000000001; + ans = 64'hC11FFFFF40000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"695047\n"); + end + x = 64'hC056EDE19622E177; + y = 64'hBEC003FFEFFFFFFF; + z = 64'hC03FF7FFFFF7FFFF; + ans = 64'hC03FF7F486298432; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"695661\n"); + end + x = 64'h3CA0000000000001; + y = 64'hFFF0000000000001; + z = 64'hBFE0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"696275\n"); + end + x = 64'hC80F000000001FFF; + y = 64'h458088C216B51E42; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"696889\n"); + end + x = 64'h3CA0000000000001; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hBAFFFFE000003FFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"697503\n"); + end + x = 64'h3F9FFFFFFC07FFFE; + y = 64'h43FEA1961EA52621; + z = 64'hAA7DFFFFFFFDFFFF; + ans = 64'h43AEA1961AD89BC1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"698117\n"); + end + x = 64'h3FDBC2FC6A07DACB; + y = 64'h0000000000000000; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"698731\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h41E0001000000000; + z = 64'h37F0000000BFFFFF; + ans = 64'h3EA0000FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"699345\n"); + end + x = 64'h480007FFFFFFF7FF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3EBFEFFC00000000; + ans = 64'h3EBFEFFC00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"699959\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hB81000007FFFFFFE; z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; @@ -18790,12 +53664,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"803585\n"); + $fwrite(fp,"700573\n"); end - x = 64'h405000FFFFFF7FFE; - y = 64'h8010000000000000; - z = 64'h3FBFE00100000000; - ans = 64'h3FBFE00100000000; + x = 64'h41E1FFFFFF7FFFFE; + y = 64'hB81207FFFFFFFFFF; + z = 64'hAD7000080007FFFF; + ans = 64'hBA0448FFFF6FBFFD; rn = 1; rz = 0; rm = 0; @@ -18837,12 +53711,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"805599\n"); + $fwrite(fp,"701187\n"); end - x = 64'h43E04001FFFFFFFE; - y = 64'hF10581B664845094; - z = 64'h7FE6E21DA5190931; - ans = 64'h7FE6E21DA5190931; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h0010000000000000; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -18884,12 +53758,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"807613\n"); + $fwrite(fp,"701801\n"); end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'hBCA0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; + x = 64'hC01FFDFFFFFE0000; + y = 64'h3FC0008000003FFF; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -18931,717 +53805,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"809627\n"); + $fwrite(fp,"702415\n"); end - x = 64'hBC2080001FFFFFFF; - y = 64'hBFD0000000000000; - z = 64'h41F00007FFFFFFFF; - ans = 64'h41F00007FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"811641\n"); - end - x = 64'hBEF545EA51CB9AAE; - y = 64'hC3C00001FBFFFFFE; - z = 64'hCD90000000207FFF; - ans = 64'hCD90000000207FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"813655\n"); - end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'hBFE0000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"815669\n"); - end - x = 64'hC00000001FFFBFFF; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'h014F01FFFFFFFFFE; - ans = 64'h400000001FFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"817683\n"); - end - x = 64'h4055BD069A83DB81; - y = 64'hBD000006FFFFFFFE; - z = 64'h43F0005FFFFFFFFF; - ans = 64'h43F0005FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"819697\n"); - end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC000000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"821711\n"); - end - x = 64'hC7EDFFFFFFFFFBFE; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'h7FDF0896F4F2CB64; - ans = 64'h7FDF0896F4F2CB64; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"823725\n"); - end - x = 64'hC3DFFDFF00000000; - y = 64'hC34000FFFFFFFFEF; - z = 64'h381FF7FFF8000000; - ans = 64'h472FFFFEDFEFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"825739\n"); - end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC340000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"827753\n"); - end - x = 64'h3FFB8ACD8E55074B; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h41C3D05E9BB88A09; - ans = 64'hC35B8ACD846CD7FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"829767\n"); - end - x = 64'hC7F002000000001F; - y = 64'h40BFFF0200000000; - z = 64'h3F6FFFDFFFFDFFFF; - ans = 64'hC8C00180F020001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"831781\n"); - end - x = 64'h3CAFFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - z = 64'h3FF0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"833795\n"); - end - x = 64'hC1FF0000000001FF; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h000FFF0008000000; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"835809\n"); - end - x = 64'h3F9FFEFFEFFFFFFF; - y = 64'hFFD0000F80000000; - z = 64'hC1D01000001FFFFF; - ans = 64'hFF7FFF1EEF07F07F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"837823\n"); - end - x = 64'h3FD0000000000000; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"839837\n"); - end - x = 64'h482FFFFFFFFFF3FF; + x = 64'h3CAFFFFFFFFFFFFF; y = 64'h001FFFFFFFFFFFFF; - z = 64'hBF210000000001FE; - ans = 64'hBF210000000001FE; + z = 64'hAA100008003FFFFF; + ans = 64'hAA100008003FFFFF; rn = 1; rz = 0; rm = 0; @@ -19683,12 +53852,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"841851\n"); + $fwrite(fp,"703029\n"); end - x = 64'h40056A10A60BBB53; - y = 64'h43FFF7FF7FFFFFFF; - z = 64'h47DFC00003FFFFFF; - ans = 64'h47DFC00003FFFFFF; + x = 64'hC349DB908A4890C2; + y = 64'hC3CFFFFFFC07FFFF; + z = 64'hC3F000FFFF7FFFFF; + ans = 64'h4729DB9087139592; rn = 1; rz = 0; rm = 0; @@ -19730,12 +53899,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"843865\n"); + $fwrite(fp,"703643\n"); end - x = 64'h3FD0000000000000; + x = 64'hC1D00000803FFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"704257\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h357AA218DB1B86F0; + z = 64'hC04A768475032095; + ans = 64'hC04A768475032095; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"704871\n"); + end + x = 64'hCB6C57A1E8AE7848; + y = 64'h3CA0000000000001; + z = 64'h440FF00000000200; + ans = 64'hC81C57A1E8AE784A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"705485\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hD1112CAD3B4C5218; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'hCDD12CAD3B4C5217; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"706099\n"); + end + x = 64'h41CFC00400000000; + y = 64'h40FFFFFF81FFFFFF; + z = 64'h532FFFFFFFFDDFFE; + ans = 64'h532FFFFFFFFDDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"706713\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -19777,12 +54181,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"845879\n"); + $fwrite(fp,"707327\n"); end - x = 64'h00000FF7FFFFFFFF; + x = 64'h800001FBFFFFFFFF; + y = 64'h252000000000203F; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"707941\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h3FD0000000000001; + z = 64'hBF4200000001FFFF; + ans = 64'hBF4200000001FDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"708555\n"); + end + x = 64'h43E3D73EF74F964F; + y = 64'hD51FFFE0000003FE; + z = 64'hC0311B57B645A4AC; + ans = 64'hD913D72B2010A179; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"709169\n"); + end + x = 64'hC3CFFFFFEFFFFFFA; y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h47F000000003FFFC; - ans = 64'h47F000000003FFFC; + z = 64'hBFF0000000000000; + ans = 64'hC3BFFFFFEFFFFFF9; rn = 1; rz = 0; rm = 0; @@ -19824,12 +54369,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"847893\n"); + $fwrite(fp,"709783\n"); end - x = 64'hFFDFFFFFBFFFFFFD; - y = 64'h47FFFFFFFFFDFC00; - z = 64'h3FF387DF37B4277C; - ans = 64'hFFF0000000000000; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h7FFFD9879D865521; + z = 64'hBCAE2425EBD33EF3; + ans = 64'h7FFFD9879D865521; rn = 1; rz = 0; rm = 0; @@ -19871,12 +54416,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"849907\n"); + $fwrite(fp,"710397\n"); end - x = 64'h3FD0000000000000; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3FD0000000000003; + x = 64'hC801212E737DEEDD; + y = 64'h3FE0000000000000; + z = 64'hC1E000000002FFFF; + ans = 64'hC7F1212E737DEEDD; rn = 1; rz = 0; rm = 0; @@ -19918,12 +54463,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"851921\n"); + $fwrite(fp,"711011\n"); end - x = 64'h381F000200000000; - y = 64'h3FF0000000000001; - z = 64'h3FDDDE28AA408892; - ans = 64'h3FDDDE28AA408892; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h43EFE00000000FFF; + z = 64'h0010000000000000; + ans = 64'h40AFE00000000FFE; rn = 1; rz = 0; rm = 0; @@ -19965,12 +54510,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"853935\n"); + $fwrite(fp,"711625\n"); end - x = 64'hF4D0700000000000; - y = 64'h4061AE8809F49782; - z = 64'hC3EFFFFFF7FFFF7F; - ans = 64'hF5422A4DC23A47A7; + x = 64'hC7F00FFFFFFFFFDF; + y = 64'h06AAB018F1034A95; + z = 64'h426FFFFFFE003FFE; + ans = 64'h426FFFFFFE003FFE; rn = 1; rz = 0; rm = 0; @@ -20012,12 +54557,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"855949\n"); + $fwrite(fp,"712239\n"); end - x = 64'h3FD0000000000000; - y = 64'h400FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBCB8000000000000; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hBCA0000000000000; + ans = 64'h3C9FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -20059,998 +54604,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"857963\n"); + $fwrite(fp,"712853\n"); end - x = 64'hC3CFFFFFFFFFFFC8; - y = 64'h4010000000000001; - z = 64'hBC12000800000000; - ans = 64'hC3EFFFFFFFFFFFCA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"859977\n"); - end - x = 64'hC300000200007FFE; - y = 64'h473FFDBFFFFFFFFF; - z = 64'hC1EFAE76BD77DB69; - ans = 64'hCA4FFDC3FFB8FFE9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"861991\n"); - end - x = 64'h3FD0000000000000; - y = 64'h434FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4348000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"864005\n"); - end - x = 64'hC3DC1BC00754990F; - y = 64'h7FE0000000000000; - z = 64'hD87E57C40FADB738; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"866019\n"); - end - x = 64'h4E2C074BC1E14068; - y = 64'h41F007FFFFDFFFFF; - z = 64'hFFEFFFF000003FFF; - ans = 64'hFFEFFFF000003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"868033\n"); - end - x = 64'h3FD0000000000000; - y = 64'h7FF0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"870047\n"); - end - x = 64'hC03FFDFFF7FFFFFE; - y = 64'h8000000000000000; - z = 64'hC3FFE01000000000; - ans = 64'hC3FFE01000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"872061\n"); - end - x = 64'h3EDFFFF000001FFF; - y = 64'h41EFEFFDFFFFFFFE; - z = 64'hEB9007FFFFF00000; - ans = 64'hEB9007FFFFF00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"874075\n"); - end - x = 64'h3FD0000000000000; - y = 64'h8010000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"876089\n"); - end - x = 64'hBEC0001FFFFFDFFE; - y = 64'hBCA0000000000000; - z = 64'hC7ECD2B1E4C50852; - ans = 64'hC7ECD2B1E4C50852; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"878103\n"); - end - x = 64'h4030001000000040; - y = 64'h41EFFFFFFFFFFFFF; - z = 64'h42E0000000003FFA; - ans = 64'h42E0020002003FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"880117\n"); - end - x = 64'h3FD0000000000000; - y = 64'hBFD0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FEE000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"882131\n"); - end - x = 64'h4020001000000003; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hBFE007FFFFFFFFBE; - ans = 64'hC012010FFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"884145\n"); - end - x = 64'hC3F0FFFFFF7FFFFF; - y = 64'h41FFFEFFFFFFFFFB; - z = 64'hBD9FFFFFFFFFFFDD; - ans = 64'hC600FF77FF8003FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"886159\n"); - end - x = 64'h3FD0000000000000; - y = 64'hBFF0000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"888173\n"); - end - x = 64'hC02FFFFFFFFF7FFF; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hBF6FFEFFFFFFFFFC; - ans = 64'h403FFF0007FF7FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"890187\n"); - end - x = 64'hB7F84864126F0E11; - y = 64'hC0EED575F05EAC2D; - z = 64'h9AFFFFF7FFFFFFFF; - ans = 64'h38F765D92A7779A3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"892201\n"); - end - x = 64'h3FD0000000000000; - y = 64'hC010000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"894215\n"); - end - x = 64'h3FF1896CDCA1FBD1; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h802400000FFFFFFF; - ans = 64'hC021896CDCA1FBD0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"896229\n"); - end - x = 64'hA1E0803FFFFFFFFE; - y = 64'hBFCF8000000007FE; - z = 64'h41710F56F6BCE1E1; - ans = 64'h41710F56F6BCE1E1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"898243\n"); - end - x = 64'h3FD0000000000000; - y = 64'hFFE0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFC0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"900257\n"); - end - x = 64'hC3400100001FFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hFFE00FFFFFFFFFBF; + x = 64'hFFD4BE7F3DBDF4C8; + y = 64'hFFEFFFFFFFFEFC00; + z = 64'h4340000000000001; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -21093,12 +54651,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"902271\n"); + $fwrite(fp,"713467\n"); end - x = 64'h402007FFFFFFFDFE; - y = 64'h40300000000100FF; - z = 64'hC3E0000000000FEF; - ans = 64'hC3E0000000000FEF; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h3FF0000000000000; + z = 64'hBFCA84F360B6B606; + ans = 64'hBFCA84F360B6B5FE; rn = 1; rz = 0; rm = 0; @@ -21140,12 +54698,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"904285\n"); + $fwrite(fp,"714081\n"); end - x = 64'h3FD0000000000000; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hFFFFFFFFFFFFFFFE; + x = 64'h4035891D30C0B3AA; + y = 64'hC341021685229DA4; + z = 64'h800FFFFFC0007FFF; + ans = 64'hC386E47E772D5436; rn = 1; rz = 0; rm = 0; @@ -21187,12 +54745,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"906299\n"); + $fwrite(fp,"714695\n"); end - x = 64'h000000003FEFFFFF; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hC02003FFFFFFFFF7; - ans = 64'hC02003FFFFFFFFF7; + x = 64'h2D3FFFFFFFC1FFFE; + y = 64'h3FF0000000000001; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; rn = 1; rz = 0; rm = 0; @@ -21234,12 +54792,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"908313\n"); + $fwrite(fp,"715309\n"); end - x = 64'hC7EFFFF7FFFBFFFF; - y = 64'hC990000004003FFE; - z = 64'hBFFFFFFFFFEFFFC0; - ans = 64'h518FFFF807FC7DFB; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFEFF00; + z = 64'hC7FFFBFFFFFF7FFF; + ans = 64'hC7FFFBFFFFFF7FFF; rn = 1; rz = 0; rm = 0; @@ -21281,12 +54839,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"910327\n"); + $fwrite(fp,"715923\n"); end - x = 64'h3FD0000000000001; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + x = 64'h3FCFFFFFFFFCFFFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h9C300000008000FF; + ans = 64'h3FDFFFFFFFFCFFFC; rn = 1; rz = 0; rm = 0; @@ -21328,12 +54886,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"912341\n"); + $fwrite(fp,"716537\n"); end - x = 64'h2E40000800000007; - y = 64'h3CA0000000000001; - z = 64'h537C6525D98B325E; - ans = 64'h537C6525D98B325E; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC3E87114AD0D0CDC; + z = 64'h0000000000000001; + ans = 64'hC0A87114AD0D0CDB; rn = 1; rz = 0; rm = 0; @@ -21375,12 +54933,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"914355\n"); + $fwrite(fp,"717151\n"); end - x = 64'hBFC00000FFFFFE00; - y = 64'h30DFFE0000000007; - z = 64'h3FDFFFF00000FFFE; - ans = 64'h3FDFFFF00000FFFE; + x = 64'h3E00027FFFFFFFFF; + y = 64'h3CAE000020000000; + z = 64'hBCA2000000000080; + ans = 64'hBCA1FFFFFFC3F720; rn = 1; rz = 0; rm = 0; @@ -21422,200 +54980,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"916369\n"); + $fwrite(fp,"717765\n"); end - x = 64'h3FD0000000000001; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"918383\n"); - end - x = 64'h30CBFFFFFFFEFFFF; - y = 64'h3FE0000000000001; - z = 64'h43F2000000000004; - ans = 64'h43F2000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"920397\n"); - end - x = 64'h99E5B802C2C594E2; - y = 64'hFFF1FFF7FFFFFFFE; - z = 64'h3FD000000200000F; - ans = 64'hFFF9FFF7FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"922411\n"); - end - x = 64'h3FD0000000000001; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"924425\n"); - end - x = 64'h3810000040040000; + x = 64'h3CAFFFFFFFFFFFFF; y = 64'h4000000000000001; - z = 64'hC7EFFFFFFFDEFFFE; - ans = 64'hC7EFFFFFFFDEFFFE; + z = 64'h8010000000000001; + ans = 64'h3CC0000000000000; rn = 1; rz = 0; rm = 0; @@ -21657,12 +55027,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"926439\n"); + $fwrite(fp,"718379\n"); end - x = 64'hB7FFFE000000000F; - y = 64'hDE20000000000000; - z = 64'hC34000000020FFFF; - ans = 64'h562FFE000000000F; + x = 64'h3D780000000003FF; + y = 64'hBF60000003FFFFFE; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -21704,12 +55074,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"928453\n"); + $fwrite(fp,"718993\n"); end - x = 64'h3FD0000000000001; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h4008000000000001; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hA90BB2526EA06D43; + ans = 64'h3CCFFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -21751,152 +55121,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"930467\n"); + $fwrite(fp,"719607\n"); end - x = 64'hC0958891BB2DE974; - y = 64'h4340000000000000; - z = 64'h7FFF92CC1DBEF0C0; - ans = 64'h7FFF92CC1DBEF0C0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"932481\n"); - end - x = 64'hBFB00FFFFFF00000; - y = 64'h4030000000000810; - z = 64'hC7F0000040000FFF; - ans = 64'hC7F0000040000FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"934495\n"); - end - x = 64'h3FD0000000000001; - y = 64'h7FE0000000000001; - z = 64'hC340000000000000; - ans = 64'h7FC0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"936509\n"); - end - x = 64'hBFFFFFFFEFFFFBFF; - y = 64'h7FF0000000000000; - z = 64'h001FFFF00000FFFF; + x = 64'h43EFFEF7FFFFFFFF; + y = 64'hFFDFFFFFFEFFDFFF; + z = 64'h3FD00DFFFFFFFFFF; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -21939,12 +55168,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"938523\n"); + $fwrite(fp,"720221\n"); end - x = 64'hBEEFFFFFFF800080; - y = 64'h47E000000101FFFF; - z = 64'hDCB000007FFFFFFD; - ans = 64'hDCB000007FFFFFFD; + x = 64'hC011D00DCFE601AD; + y = 64'h4010000000000000; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hC032500DCFE601AD; rn = 1; rz = 0; rm = 0; @@ -21986,10 +55215,621 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"940537\n"); + $fwrite(fp,"720835\n"); end - x = 64'h3FD0000000000001; - y = 64'h8000000000000001; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h40300000040003FE; + z = 64'hFFF0000000000042; + ans = 64'hFFF8000000000042; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"721449\n"); + end + x = 64'hFFFFFFFE00001FFF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hFFE553153A57374C; + ans = 64'hFFFFFFFE00001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"722063\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h3FE0300000000000; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"722677\n"); + end + x = 64'h43CFFFFBFFF7FFFF; + y = 64'h3CA0000001000007; + z = 64'h3E5FFFFFFFFFE001; + ans = 64'h407FFFFC01FFFFCD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"723291\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h4340000000000000; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"723905\n"); + end + x = 64'h3810007FFFE00000; + y = 64'hBFEFFC0000000FFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"724519\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h4010000003DFFFFE; + ans = 64'h4020000001EFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"725133\n"); + end + x = 64'h45BFE04000000000; + y = 64'hBFD0000002000003; + z = 64'h3220000000000200; + ans = 64'hC59FE04003FC0806; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"725747\n"); + end + x = 64'h3EF1000000000FFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'h4251000000000FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"726361\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFEC0; + z = 64'h41E002007FFFFFFF; + ans = 64'h41E002007FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"726975\n"); + end + x = 64'h3CA9C1833ECE31D2; + y = 64'h7FE0000000000001; + z = 64'h400000001FFFFFFF; + ans = 64'h7C99C1833ECE31D4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"727589\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC050000103FFFFFE; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"728203\n"); + end + x = 64'hBF40040000000003; + y = 64'h407000000000080F; + z = 64'hC0100000010007FF; + ans = 64'hC010802001000840; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"728817\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFE; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -22033,12 +55873,482 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"942551\n"); + $fwrite(fp,"729431\n"); end - x = 64'h41EFFFFFFFFFF840; + x = 64'hCF30000002001FFF; + y = 64'hC3ED50F16BE304A9; + z = 64'h4000000000000000; + ans = 64'h532D50F16F8D5D77; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"730045\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h7FF0000000000001; + z = 64'h47E0000000090000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"730659\n"); + end + x = 64'h3FEFFFFFFFDFFFDF; + y = 64'hB80FFFF7FFFFFFFD; + z = 64'h492FFFFFFFFDFFFA; + ans = 64'h492FFFFFFFFDFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"731273\n"); + end + x = 64'hC010040FFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hBCA0000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"731887\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC1E52E6A88527BEA; + z = 64'hB8172BF98589A737; + ans = 64'hBEA52E6A88527BE9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"732501\n"); + end + x = 64'h382A6081434E0C86; + y = 64'h8000000000000000; + z = 64'hC1DE0000000FFFFF; + ans = 64'hC1DE0000000FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"733115\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h480FFFE07FFFFFFF; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"733729\n"); + end + x = 64'h3FCFFFFFF8000010; + y = 64'hC3CA813954F8319C; + z = 64'h37FFFFFFFEFFFFEE; + ans = 64'hC3AA81394E57E354; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"734343\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"734957\n"); + end + x = 64'hC1E2E3C25E069868; + y = 64'hBF38D24613FBB2E4; + z = 64'h3FF0000000000001; + ans = 64'h412D4DE5A025F585; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"735571\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; y = 64'h8010000000000000; - z = 64'hBFAD057D272190FD; - ans = 64'hBFAD057D272190FD; + z = 64'hBA8C582F680D0E8F; + ans = 64'hBA8C582F680D0E8F; rn = 1; rz = 0; rm = 0; @@ -22080,12 +56390,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"944565\n"); + $fwrite(fp,"736185\n"); end - x = 64'hBFC0001007FFFFFE; - y = 64'hBFD10000000001FF; - z = 64'h99700000013FFFFF; - ans = 64'h3FA10011088001FD; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hB8100000000047FE; + z = 64'hBE7477104525BE79; + ans = 64'hBE7477104525BE79; rn = 1; rz = 0; rm = 0; @@ -22127,12 +56437,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"946579\n"); + $fwrite(fp,"736799\n"); end - x = 64'h3FD0000000000001; + x = 64'h20C000002000000E; + y = 64'h8010000000000001; + z = 64'h8010000000000001; + ans = 64'h8010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"737413\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC7FFDFFFFFFFFE00; + z = 64'hF0B46465EE8EBBB1; + ans = 64'hF0B46465EE8EBBB1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"738027\n"); + end + x = 64'h4340000400010000; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hC7F000007FFFFC00; + ans = 64'hC7F000007FFFFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"738641\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hB7EFFFFFFFFFFFEE; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"739255\n"); + end + x = 64'h4040003FFFFFFFFB; + y = 64'h43EC8C7FBE059B61; + z = 64'h434FF80000FFFFFF; + ans = 64'h443C8D31E004956F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"739869\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; y = 64'hBCA0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CABFFFFFFFFFFFE; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; rn = 1; rz = 0; rm = 0; @@ -22174,12 +56719,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"948593\n"); + $fwrite(fp,"740483\n"); end - x = 64'h404FFFFDFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'hC80FFFFFEFFFFFFF; - ans = 64'hC80FFFFFEFFFFFFF; + x = 64'hB7EFFFFE0000FFFF; + y = 64'h40503E9D4BC704B0; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -22221,12 +56766,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"950607\n"); + $fwrite(fp,"741097\n"); end - x = 64'hC3D0002040000000; - y = 64'hC0DD0F3F5E7C7DC9; - z = 64'h7FEDCD8DDF158E1F; - ans = 64'h7FEDCD8DDF158E1F; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hE48FFFFFF7FFFFEE; + ans = 64'hE48FFFFFF7FFFFEE; rn = 1; rz = 0; rm = 0; @@ -22268,12 +56813,294 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"952621\n"); + $fwrite(fp,"741711\n"); end - x = 64'h3FD0000000000001; + x = 64'h7FDF800001000000; + y = 64'h499BC83FCE25B88B; + z = 64'hC02FFFE000000FFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"742325\n"); + end + x = 64'hC1E0001FC0000000; + y = 64'hBFD0000000000000; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h41C0001FC0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"742939\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h3FF03FFFFF7FFFFF; + z = 64'hB7ED50191FEBB6C0; + ans = 64'h3CB03FFFFF7FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"743553\n"); + end + x = 64'hFFD0000000037FFE; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h434FFAFFFFFFFFFF; + ans = 64'h7FC0000000037FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"744167\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hBF7DFFFF7FFFFFFE; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"744781\n"); + end + x = 64'h98D4F4367275AF07; + y = 64'h3FEFF80003FFFFFF; + z = 64'h802FFFFC00000007; + ans = 64'h98D4EEF967779869; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"745395\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; y = 64'hBFE0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF2000000000001; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -22315,12 +57142,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"954635\n"); + $fwrite(fp,"746009\n"); end - x = 64'h401FFDFFFFF00000; + x = 64'h3F9D0C184AFAD181; + y = 64'hFFE001E000000000; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'hFF8D0F7FB5D39AE6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"746623\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hBFE0000000000001; + z = 64'h43F03F7FFFFFFFFF; + ans = 64'h43F03F7FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"747237\n"); + end + x = 64'h0006BAA6E6628D4B; + y = 64'h3D2FFFF000002000; + z = 64'hBFEEFFFFFFFFC000; + ans = 64'hBFEEFFFFFFFFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"747851\n"); + end + x = 64'h3FB002000000FFFF; y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hC3400D15CAF2C5CA; - ans = 64'hC3400D15CAF2C5CE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -22362,12 +57330,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"956649\n"); + $fwrite(fp,"748465\n"); end - x = 64'h3FD001FFFF000000; - y = 64'h7FEC336E7E5B0C30; - z = 64'h43EFFFFFFFFFDFFF; - ans = 64'h7FCC36F4EA67A0AA; + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hB32832CD4DA733A1; + z = 64'hB7F0010000100000; + ans = 64'hB7F0010000100000; rn = 1; rz = 0; rm = 0; @@ -22409,10 +57377,13875 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"958663\n"); + $fwrite(fp,"749079\n"); + end + x = 64'hC3FFFFFF04000000; + y = 64'hBFF0000000000001; + z = 64'hBCBFFFFFFFFF0006; + ans = 64'h43FFFFFF04000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"749693\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h41E7FFFFFFFFFFFC; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFF9FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"750307\n"); + end + x = 64'hA253DCAE002F464A; + y = 64'hE920001000000080; + z = 64'h0020000000FEFFFF; + ans = 64'h4B83DCC1DCDD4718; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"750921\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"751535\n"); + end + x = 64'h5750000000000040; + y = 64'h400AB0370585F185; + z = 64'h3FD0000000000000; + ans = 64'h576AB0370585F1F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"752149\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC000000000000000; + z = 64'h3CA2000000000400; + ans = 64'hBCB6FFFFFFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"752763\n"); + end + x = 64'hC10DEB4451CF9086; + y = 64'h4770100000004000; + z = 64'hD5EFFFFEFFFFFFDF; + ans = 64'hD5EFFFFEFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"753377\n"); + end + x = 64'hF0863251E8FE0225; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"753991\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h41F007FFEFFFFFFE; + z = 64'h404FFFFFFBFFFFF8; + ans = 64'h405000000201FFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"754605\n"); + end + x = 64'h3F8FFFE001FFFFFE; + y = 64'hC010000000000000; + z = 64'h3CA0008000000FFF; + ans = 64'hBFAFFFE001FFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"755219\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h37E71F98C279DBBC; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"755833\n"); + end + x = 64'h37E00400001FFFFE; + y = 64'h43F8400F900F53B5; + z = 64'hC3EFFFFFBFFFF7FE; + ans = 64'hC3EFFFFFBFFFF7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"756447\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h4010000000000000; + ans = 64'h400FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"757061\n"); + end + x = 64'hBDE1C565EC0236AF; + y = 64'hBCAFFFF000000100; + z = 64'h3CA0000000000001; + ans = 64'h3CA000000011C55E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"757675\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hC02CBE486A2B0809; + ans = 64'hC02CBE486A2B080A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"758289\n"); + end + x = 64'hBFDFFDFFFBFFFFFF; + y = 64'h3F0F7FFFFFF80000; + z = 64'h4D90000000010006; + ans = 64'h4D90000000010006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"758903\n"); + end + x = 64'h28A9110868DC09E4; + y = 64'hC340000000000001; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"759517\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC02FBFFFFEFFFFFF; + z = 64'h4803ABE97F306C7A; + ans = 64'h4803ABE97F306C7A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"760131\n"); + end + x = 64'hBFC000000FFFFE00; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h40EBFFFFFEFFFFFF; + ans = 64'h432000001001BDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"760745\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC7F0000400000003; + z = 64'hBFF0000000000001; + ans = 64'hC4B0000400000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"761359\n"); + end + x = 64'hBEF2000000001FFE; + y = 64'h41D9A46BD6DA0E6B; + z = 64'h001FFFFFEFFFFF7F; + ans = 64'hC0DCD8F951B5837E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"761973\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hFFE0000000000001; + z = 64'h4000000000000001; + ans = 64'hFCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"762587\n"); + end + x = 64'h000667C5D67E1D85; + y = 64'h3FDFEFFFFDFFFFFF; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h002199247CCB1886; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"763201\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h43DC000001000000; + ans = 64'hFCAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"763815\n"); + end + x = 64'h400FFFFBFFFFEFFF; + y = 64'hC3FFC00000000000; + z = 64'h37F007FFFFFFFFBF; + ans = 64'hC41FBFFC07FFF01F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"764429\n"); + end + x = 64'hC02DA3D0B1B2F367; + y = 64'hFFF0000000000000; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"765043\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h43CFFFFFFFFFFF0F; + z = 64'hC80000FFFFFEFFFF; + ans = 64'hC80000FFFFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"765657\n"); + end + x = 64'hBFDFFFFFFFFFFFF3; + y = 64'hFFF0000000000001; + z = 64'h3FDFFFFFFFFFF7FB; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"766271\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h41F080FFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFDEFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"766885\n"); + end + x = 64'hBEC0080000003FFF; + y = 64'h39300003FFFFFFEF; + z = 64'hB80F865401D278F7; + ans = 64'hB817C72C01E95C73; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"767499\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h0000000000000000; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"768113\n"); + end + x = 64'h000007FFFFFFFFFE; + y = 64'h3F6FFFFFFE01FFFE; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h00100007FFFFFF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"768727\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h0000000000000001; + z = 64'hC0583D940632C786; + ans = 64'hC0583D940632C786; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"769341\n"); + end + x = 64'h7FEFFFFBFFFFFF80; + y = 64'h4026126760B56D8C; + z = 64'hD92BBFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"769955\n"); + end + x = 64'hC1CFFFE000000040; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"770569\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h4060000001000006; + z = 64'h4070001FFFFF7FFE; + ans = 64'h4070001FFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"771183\n"); + end + x = 64'h548FFFFFC00FFFFE; + y = 64'h0010000000000000; + z = 64'h817B000000000000; + ans = 64'h14AFFFFFC00FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"771797\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h43C001000001FFFF; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h407FFA000003FFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"772411\n"); + end + x = 64'hC01FF7FFFFFEFFFF; + y = 64'hC3F2000000000FFE; + z = 64'h4800007FE0000000; + ans = 64'h4800007FE0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"773025\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"773639\n"); + end + x = 64'hBFEFFFFFFFDBFFFF; + y = 64'hB7FFFFFFFFF7FFF7; + z = 64'h0000000000000000; + ans = 64'h37FFFFFFFFD3FFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"774253\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h3CA0000000000000; + z = 64'hC49FF7FFFE000000; + ans = 64'hC49FF7FFFE000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"774867\n"); + end + x = 64'h51E7FFFFFFFFFF7F; + y = 64'h40129211363ADFB4; + z = 64'hCB697B092581A9BA; + ans = 64'h520BDB19D1584EF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"775481\n"); + end + x = 64'hC074007FFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h4010000000000000; + ans = 64'h400FFFFFFFFFFF60; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"776095\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h48000000000000EF; + z = 64'hA20003FFFF800000; + ans = 64'h44C00000000000EE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"776709\n"); + end + x = 64'h40B0000000003FF8; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h438FFEFFFFFFFFDF; + ans = 64'h438FFEFFFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"777323\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC7F9D14ED895890F; + z = 64'hBFD0000000000000; + ans = 64'hC4B9D14ED895890D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"777937\n"); + end + x = 64'h801000000007FFFF; + y = 64'hBFD36A9BB1F93547; + z = 64'h405000000000006F; + ans = 64'h405000000000006F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"778551\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"779165\n"); + end + x = 64'h002FFEF7FFFFFFFF; + y = 64'hC08FFFFE0FFFFFFE; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"779779\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h402FFF801FFFFFFE; + ans = 64'h402FFF801FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"780393\n"); + end + x = 64'hBEC02000001FFFFF; + y = 64'hCC5000DFFFFFFFFF; + z = 64'hB7F0010000000040; + ans = 64'h4B2020E1C02001BE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"781007\n"); + end + x = 64'h3CA000000FFF0000; + y = 64'h3FE0000000000001; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"781621\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h403FFFFFBFFFEFFE; + z = 64'h37ED46FC2B0023A2; + ans = 64'h3CFFFFFFBFFFEFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"782235\n"); + end + x = 64'hB7E9EFD68B497421; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3E6000000000040E; + ans = 64'h3E6000000000040E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"782849\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h000266016A39E777; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"783463\n"); + end + x = 64'h37F95059156CD4C4; + y = 64'hC3F01DFFFFFFFFFF; + z = 64'hC7F0002000000004; + ans = 64'hC7F0002000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"784077\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h3FF0000000000001; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"784691\n"); + end + x = 64'h80070847320BC888; + y = 64'h7CE47DBA0F14EAF5; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"785305\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hB7F4FECA1F205474; + ans = 64'h3CBFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"785919\n"); + end + x = 64'hC03FFE001FFFFFFF; + y = 64'hC5DCEA96744E1936; + z = 64'h43C0000003EFFFFF; + ans = 64'h462CE8C7E7D1AAC8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"786533\n"); + end + x = 64'hBFD7FFFFFFBFFFFF; + y = 64'h4000000000000000; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FF4000000200000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"787147\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC5CE77F1E2F669DB; + z = 64'h49C3FFFFFFFDFFFF; + ans = 64'h49C3FFFFFFFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"787761\n"); + end + x = 64'h3D1FFFFFFFFFFFF5; + y = 64'h4000000000000001; + z = 64'h32F000007FFFFFFF; + ans = 64'h3D2FFFFFFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"788375\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC3C0FFFFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'hC080FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"788989\n"); + end + x = 64'h40D00001FFBFFFFF; + y = 64'h66B7849965C4EBF6; + z = 64'hBCC000004000007E; + ans = 64'h6797849C55FA0648; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"789603\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h4010000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CD3FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"790217\n"); + end + x = 64'h761FAA6A41261C23; + y = 64'h477FFF8000000002; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'h7DAFA9EB977D178D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"790831\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h4010000000000001; + z = 64'h4039A83A2B1F9F06; + ans = 64'h4039A83A2B1F9F06; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"791445\n"); + end + x = 64'h3CAA3DE7B7AA7C1C; + y = 64'h3FEFFFFFFF8001FF; + z = 64'h43F00000000DFFFE; + ans = 64'h43F00000000DFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"792059\n"); + end + x = 64'h6A9FFFFF07FFFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h6ACFFFFF07FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"792673\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h36DBC55BED797727; + z = 64'hC10EF56A7E932EFD; + ans = 64'hC10EF56A7E932EFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"793287\n"); + end + x = 64'hB809C1DDC84B5E09; + y = 64'h4340000000000000; + z = 64'hC72FFDF7FFFFFFFF; + ans = 64'hC72FFDF7FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"793901\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC51574C4CCC1F217; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hC1D574C4CCC1F216; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"794515\n"); + end + x = 64'hC34000007FFFEFFF; + y = 64'hC800000000007FFA; + z = 64'hDB9FFFFFFF6FFFFE; + ans = 64'hDB9FFFFFFF6FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"795129\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"795743\n"); + end + x = 64'hC02F000003FFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"796357\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h7FE0000000000000; + z = 64'h3F2FFDFFFFFFFF80; + ans = 64'h7C9FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"796971\n"); + end + x = 64'hB7F07FFFFFFFFFFC; + y = 64'h7FDFFFFFFFFF7C00; + z = 64'hC03FFFFFC0000003; + ans = 64'hF7E07FFFFFFFBBEC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"797585\n"); + end + x = 64'h801FFFFBFEFFFFFE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h3FE0000000000000; + ans = 64'hC01DFFFBFEFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"798199\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hBFDFEFFFFFFFEFFF; + z = 64'h43A0043FFFFFFFFE; + ans = 64'h43A0043FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"798813\n"); + end + x = 64'hC017A0FB0E9F66C3; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hFFDFEFFFFFFFFFDE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"799427\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC01FFFBFBFFFFFFF; + z = 64'h8000000000000000; + ans = 64'hBCDFFFBFBFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"800041\n"); + end + x = 64'hBFBFFDC000000000; + y = 64'h37F003FFFFFFFEFE; + z = 64'hC093287BC3456222; + ans = 64'hC093287BC3456222; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"800655\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h0010000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"801269\n"); + end + x = 64'hC060000080000400; + y = 64'hBFD000000100000E; + z = 64'hC010000000000001; + ans = 64'h403C00010200082C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"801883\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h41C0000000000FE0; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"802497\n"); + end + x = 64'hC7EFC000007FFFFF; + y = 64'h3FBFFFFFFFFFE7FE; + z = 64'h3FEBA884A0712B77; + ans = 64'hC7BFC000007FE82D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"803111\n"); + end + x = 64'h8022424C23A46355; + y = 64'h8000000000000001; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"803725\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hD4DFFFF800800000; + z = 64'h401FFC7FFFFFFFFE; + ans = 64'hD19FFFF8007FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"804339\n"); + end + x = 64'h3FEA91C55BA6D318; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h38A3B6C3AD39060C; + ans = 64'h38A3B6C3AD39060C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"804953\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hBFDFFFDFFFFFFFF0; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"805567\n"); + end + x = 64'h381FDFFFFFFFFC00; + y = 64'h3E400000400FFFFF; + z = 64'hC03605C500F49014; + ans = 64'hC03605C500F49014; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"806181\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h8010000000000001; + z = 64'h0000000000000001; + ans = 64'h0000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"806795\n"); + end + x = 64'hC0E0000000000401; + y = 64'h80100000083FFFFE; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"807409\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h408FFFE0000003FF; + ans = 64'h408FFFE0000003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"808023\n"); + end + x = 64'h3C4000007FFFFFFB; + y = 64'h3FB0020000080000; + z = 64'hC11FF7FFFFFFFFF0; + ans = 64'hC11FF7FFFFFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"808637\n"); + end + x = 64'hC7E00000000F7FFE; + y = 64'hBCA0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h44900000000F7FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"809251\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFEFC; + z = 64'hFFD00000043FFFFF; + ans = 64'hFFD00000043FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"809865\n"); + end + x = 64'hC800080000000002; + y = 64'hBCA0000000000001; + z = 64'h00000000000000FB; + ans = 64'h44B0080000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"810479\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h47F00000FFBFFFFE; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"811093\n"); + end + x = 64'hBFF004000003FFFF; + y = 64'h84F9917D0C96A324; + z = 64'hB450100000080000; + ans = 64'hB450100000080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"811707\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"812321\n"); + end + x = 64'h41FFFFFFFEFFFDFF; + y = 64'h0DEFFFFFFF007FFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"812935\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hBFD0000000000001; + z = 64'h4030808000000000; + ans = 64'h4030808000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"813549\n"); + end + x = 64'hC0300000000003EF; + y = 64'h408FFFBFFFEFFFFF; + z = 64'hBDAFFFE01FFFFFFE; + ans = 64'hC0CFFFBFFFF007E5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"814163\n"); + end + x = 64'h4173847C57956A54; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'hC163847C57956A53; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"814777\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hFFF0000006000000; + z = 64'h377FFFFF80001FFF; + ans = 64'hFFF8000006000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"815391\n"); + end + x = 64'h3FEFAFFFFFFFFFFE; + y = 64'hBFE0000000000000; + z = 64'h40B000007FFFDFFE; + ans = 64'h40AFFF037FFFBFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"816005\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC7EFFFFFFFFFEFFF; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'hC4AFFFFF7FFFEFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"816619\n"); + end + x = 64'h3F1AF153D63208C5; + y = 64'h41CFEDD90920FE45; + z = 64'hC3D0000000000820; + ans = 64'hC3D00000000007B4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"817233\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"817847\n"); + end + x = 64'h3FF000010003FFFE; + y = 64'h40D000000DFFFFFF; + z = 64'hBFF0000000000000; + ans = 64'h40CFFF821C0801BA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"818461\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hBFF0000000000000; + z = 64'hEB9C3D16BF65A760; + ans = 64'hEB9C3D16BF65A760; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"819075\n"); + end + x = 64'h4341BC45DB03D622; + y = 64'h480FFFFFFFBFFFFA; + z = 64'h80000DFFFFFFFFFE; + ans = 64'h4B61BC45DAE05D93; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"819689\n"); + end + x = 64'hBE53168DFE97BEEE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h0010000000000000; + ans = 64'h3E63168DFE97BEED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"820303\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h402000000001FFFB; + z = 64'h40400000007FFFFA; + ans = 64'h40400000007FFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"820917\n"); + end + x = 64'h7FFD8B8508E0B4F6; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h381FFFFFFFFF7FFF; + ans = 64'h7FFD8B8508E0B4F6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"821531\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h49F000000003FEFE; + z = 64'h4340000000000000; + ans = 64'h46B000000003FEFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"822145\n"); + end + x = 64'h002FFFE0000000FF; + y = 64'h629000007FFDFFFF; + z = 64'hC1E002FFFFFFFFFF; + ans = 64'hC1E002FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"822759\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC000000000000001; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"823373\n"); + end + x = 64'h9BF080000001FFFF; + y = 64'hC1E3B08DE8F3BD01; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"823987\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hC01000000020007F; + ans = 64'hC010000000200080; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"824601\n"); + end + x = 64'hBFAFFFFFFC03FFFE; + y = 64'h3CA00003FFFEFFFE; + z = 64'h3CA0040000002000; + ans = 64'h3C9E07FF80402010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"825215\n"); + end + x = 64'hBFAFFFFFFFFC03FF; + y = 64'hC010000000000001; + z = 64'h0000000000000001; + ans = 64'h3FCFFFFFFFFC0401; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"825829\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hBFCFFE0000FFFFFF; + z = 64'h3ED001FFFFFFDFFF; + ans = 64'h3ED001FFFFFEE00F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"826443\n"); + end + x = 64'h3232BD6AC09064AA; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hB8000000001FFF80; + ans = 64'hB8000000001FFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"827057\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFF08; + z = 64'h4010000000000001; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"827671\n"); + end + x = 64'hF9000FFFFFFEFFFF; + y = 64'hC00FFFFFD7FFFFFF; + z = 64'h4FEF54534F810F43; + ans = 64'h79200FFFEBEAFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"828285\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC340000000000000; + z = 64'hC340000000000001; + ans = 64'hC340000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"828899\n"); + end + x = 64'hBF0B677CE222C3C4; + y = 64'h5B5007FFFFFFEFFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hDA6B7530A093B9BD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"829513\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC04C8260C328A10C; + ans = 64'hC04E8260C328A10C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"830127\n"); + end + x = 64'hC32351DA9045BE0B; + y = 64'h83FFFFFFFBFFFFFF; + z = 64'h37FFFFFFDFFF8000; + ans = 64'h37FFFFFFDFFF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"830741\n"); + end + x = 64'h3E298A451963779F; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"831355\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC3C1127530CEDD0B; + z = 64'h41CFFFFFFFFFFFA0; + ans = 64'h41CFFFFEEED8AC93; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"831969\n"); + end + x = 64'h41C000000040001F; + y = 64'hFFE0000000000001; + z = 64'h3A297E3D1F64A3F4; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"832583\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC3FFFE1FFFFFFFFF; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'hC0BFFA1FFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"833197\n"); + end + x = 64'h58EFFFFEFFEFFFFF; + y = 64'h3FFFFFFFFFF00000; + z = 64'hBFE7FFFFFBFFFFFF; + ans = 64'h58FFFFFEFFE00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"833811\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hFCAFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"834425\n"); + end + x = 64'h41DFEFFFFFBFFFFF; + y = 64'hBCAFF00000001FFF; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBE9FE00800003FEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"835039\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hFFF0000000000001; + z = 64'h7FF0000003FFE000; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"835653\n"); + end + x = 64'hFFE9564FB99A2A23; + y = 64'h3FEFFFFFF7FFC000; + z = 64'h3F63E56EDFA19196; + ans = 64'hFFE9564FB3446388; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"836267\n"); + end + x = 64'hB970001FFFFEFFFE; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"836881\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h801A6DCDC520170C; + z = 64'h37E00004000000FE; + ans = 64'h37E00004000000FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"837495\n"); + end + x = 64'h4380003FFFDFFFFF; + y = 64'h0000000000000000; + z = 64'hC1CFFFFFFFFFFDEF; + ans = 64'hC1CFFFFFFFFFFDEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"838109\n"); + end + x = 64'h3FD0000000000000; + y = 64'h3FCFFFFBF0000000; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h40007FFFEFBFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"838723\n"); + end + x = 64'h441FFFFFFFFFFFF5; + y = 64'hC80FF800001FFFFE; + z = 64'h47FA1083AB1A334C; + ans = 64'hCC3FF800001FFFF3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"839337\n"); + end + x = 64'h3FD0000000000000; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"839951\n"); + end + x = 64'h45C000000080001E; + y = 64'h4340007FFE000000; + z = 64'hBCA0000000000000; + ans = 64'h4910007FFE80041E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"840565\n"); + end + x = 64'h3FD0000000000000; + y = 64'h0010000000000000; + z = 64'hBAD00000003FEFFF; + ans = 64'hBAD00000003FEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"841179\n"); + end + x = 64'h0000010000000400; + y = 64'h37E083FFFFFFFFFF; + z = 64'hC7EFFFFFFF80FFFE; + ans = 64'hC7EFFFFFFF80FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"841793\n"); + end + x = 64'hC3D0001FFDFFFFFF; + y = 64'h0010000000000001; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"842407\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBFD0000000000140; + z = 64'hC1D1CA517F76AEDD; + ans = 64'hC1D1CA517F7AAEDD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"843021\n"); + end + x = 64'hC7FFFFFFFFFE001E; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h38507FFFFFFF7FFE; + ans = 64'h38507FFFFFFF7FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"843635\n"); + end + x = 64'h3FD0000000000000; + y = 64'hB80FFFFF000001FF; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"844249\n"); + end + x = 64'hB7FF0007FFFFFFFE; + y = 64'h401FE0000000007F; + z = 64'h41D003FFFFFFFFFD; + ans = 64'h41D003FFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"844863\n"); + end + x = 64'h3FD0000000000000; + y = 64'h3CA0000000000001; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"845477\n"); + end + x = 64'hC0B0488993492A6B; + y = 64'h5B1FFFFFDFC00000; + z = 64'h8010000000000001; + ans = 64'hDBE0488982E00FC5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"846091\n"); + end + x = 64'h3FD0000000000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hC000084000000000; + ans = 64'hC000084000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"846705\n"); + end + x = 64'hC1EFFFFFC0007FFF; + y = 64'h3FFFFFFFFFFFFFEE; + z = 64'hC8BFFFFFC00003FE; + ans = 64'hC8BFFFFFC00003FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"847319\n"); + end + x = 64'h375EFFFFFFFDFFFF; + y = 64'h3FD0000000000000; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"847933\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC000000400000006; + z = 64'hBC1FBFFF80000000; + ans = 64'hBFE0000400000006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"848547\n"); + end + x = 64'hC7E0010000FFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hBF8FFFFFFFF83FFE; + ans = 64'hC7D0010000FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"849161\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC0500800000001FE; + z = 64'h3FE0000000000001; + ans = 64'hC02F1000000003FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"849775\n"); + end + x = 64'hC800000004400000; + y = 64'hBE4FFFFEFFFF0000; + z = 64'h800FDBF9EA11BBF4; + ans = 64'h465FFFFF087EFFBC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"850389\n"); + end + x = 64'h3FD0000000000000; + y = 64'h3FE0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBFEC000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"851003\n"); + end + x = 64'h420E5A3C24CF124B; + y = 64'hC1E07FFFFBFFFFFF; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'hC3FF4D0DFE5EFBD2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"851617\n"); + end + x = 64'h3FD0000000000000; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3FC3FFFFFFFC0000; + ans = 64'h3FD9FFFFFFFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"852231\n"); + end + x = 64'hB80AF03ED31C2128; + y = 64'h43C0003FFE000000; + z = 64'h47FD72CA9372EDB0; + ans = 64'h47FD72CA9372EDB0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"852845\n"); + end + x = 64'hB81FFFFFFDFFFFFA; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"853459\n"); + end + x = 64'h3FD0000000000000; + y = 64'hD414000000000000; + z = 64'hC3DBDCEC84BBB9FD; + ans = 64'hD3F4000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"854073\n"); + end + x = 64'h37F10F90DAD1F099; + y = 64'h3FF0000000000001; + z = 64'hBE51FF9882DDA3CC; + ans = 64'hBE51FF9882DDA3CC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"854687\n"); + end + x = 64'h3FD0000000000000; + y = 64'hFFFA27F828AA83E8; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'hFFFA27F828AA83E8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"855301\n"); + end + x = 64'hC01FFFFFFFC00008; + y = 64'hBFA7D979591E69F2; + z = 64'hB81FFFFFFFFC0004; + ans = 64'h3FD7D97958EEB705; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"855915\n"); + end + x = 64'h3FD0000000000000; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"856529\n"); + end + x = 64'h7FE0DFFFFFFFFFFF; + y = 64'hBFCFFFFFFFDFFBFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"857143\n"); + end + x = 64'h3FD0000000000000; + y = 64'h4000000000000001; + z = 64'h8017C6373AB1DB0C; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"857757\n"); + end + x = 64'hBFE000800000003F; + y = 64'hC3D0040000003FFF; + z = 64'hBFBA1A85F9F711EA; + ans = 64'h43C0048020004040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"858371\n"); + end + x = 64'hC7F0001002000000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC810001001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"858985\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBB12976036C01C4E; + z = 64'h7FDFFF800000000F; + ans = 64'h7FDFFF800000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"859599\n"); + end + x = 64'h3FFF4B7FA078868F; + y = 64'h4010000000000000; + z = 64'h80200000001FFFFF; + ans = 64'h401F4B7FA078868F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"860213\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBFDCCB5937B9B37F; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'hBFBCCB5937B9B36F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"860827\n"); + end + x = 64'h800000000000007E; + y = 64'hFFD26A0F710537A9; + z = 64'hC01B3B74DE550046; + ans = 64'hC01B3B74DE550022; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"861441\n"); + end + x = 64'h3FD0000000000000; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h3FF8000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"862055\n"); + end + x = 64'hB9FC1DF69E92D913; + y = 64'h40800000040000FE; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"862669\n"); + end + x = 64'h3FD0000000000000; + y = 64'h4340000000000000; + z = 64'hC80BB201F0787373; + ans = 64'hC80BB201F0787373; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"863283\n"); + end + x = 64'hBE6CB25FEF8F51E0; + y = 64'hB0A0000000008002; + z = 64'hD5CFDFFFFDFFFFFF; + ans = 64'hD5CFDFFFFDFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"863897\n"); + end + x = 64'h47EFFFFFFFFFBDFE; + y = 64'h4340000000000001; + z = 64'hC000000000000000; + ans = 64'h4B3FFFFFFFFFBE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"864511\n"); + end + x = 64'h3FD0000000000000; + y = 64'h3800FDCBA1FA0B89; + z = 64'hC030003FFEFFFFFF; + ans = 64'hC030003FFEFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"865125\n"); + end + x = 64'h35DD7F70FBF55C6F; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h7FEA275826182B56; + ans = 64'h7FEA275826182B56; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"865739\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC3E0000000800007; + z = 64'h3CA0000000000000; + ans = 64'hC3C0000000800007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"866353\n"); + end + x = 64'h4340FFFFFFFFF800; + y = 64'h38ADFFFFFFBFFFFE; + z = 64'hBFD589A27F2B5461; + ans = 64'hBFD589A27F2B5461; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"866967\n"); + end + x = 64'h3FD0000000000000; + y = 64'h7FE0000000000001; + z = 64'hBFD0000000000000; + ans = 64'h7FC0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"867581\n"); + end + x = 64'h38FFFFE07FFFFFFE; + y = 64'h434000007FFF7FFF; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"868195\n"); + end + x = 64'h3FD0000000000000; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hB81000003FFFFF80; + ans = 64'h7FCFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"868809\n"); + end + x = 64'hBD7FEFFFFFFF7FFF; + y = 64'hC1FFFFFFF000007E; + z = 64'h6FAFFFFFFFFFFBE0; + ans = 64'h6FAFFFFFFFFFFBE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"869423\n"); + end + x = 64'hC1E0000000003BFE; + y = 64'h7FF0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"870037\n"); + end + x = 64'h3FD0000000000000; + y = 64'h382100000001FFFF; + z = 64'h43D0000010800000; + ans = 64'h43D0000010800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"870651\n"); + end + x = 64'h0EDFFFFFFFBFBFFE; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hC70FFFFFFF7BFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"871265\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC1FFF80FFFFFFFFF; + z = 64'h0010000000000001; + ans = 64'hC1DFF80FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"871879\n"); + end + x = 64'h77500007FFFFFFFF; + y = 64'hB7EFFE0400000000; + z = 64'hC3CF7FFFFFFFFF00; + ans = 64'hEF4FFE13FF01FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"872493\n"); + end + x = 64'h3FD0000000000000; + y = 64'h8000000000000000; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"873107\n"); + end + x = 64'h41DFFFFFFFFFFBFE; + y = 64'hBFB00008007FFFFE; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFBFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"873721\n"); + end + x = 64'h3FD0000000000000; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC3FFF0000003FFFF; + ans = 64'hC3FFF0000003FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"874335\n"); + end + x = 64'hBFE0000000000077; + y = 64'hC1E00000000003BE; + z = 64'hBFF000010000001F; + ans = 64'h41CFFFFFFF800862; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"874949\n"); + end + x = 64'h3A800000027FFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"875563\n"); + end + x = 64'h3FD0000000000000; + y = 64'hB2CFFFFE07FFFFFF; + z = 64'hBFBFFFFFFFE001FE; + ans = 64'hBFBFFFFFFFE001FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"876177\n"); + end + x = 64'hC00FFE00FFFFFFFF; + y = 64'h8010000000000001; + z = 64'h9DAFFFFFC0000001; + ans = 64'h9DAFFFFFC0000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"876791\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC30F8FBDC122265C; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hC2EF8FBDC122265C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"877405\n"); + end + x = 64'h0E1FFFFFFFF0003F; + y = 64'h8D33FFFFFFFDFFFE; + z = 64'h43CF12C07801790B; + ans = 64'h43CF12C07801790B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"878019\n"); + end + x = 64'h3FD0000000000000; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h8023FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"878633\n"); + end + x = 64'hC16FFFFFFFFFFFFE; + y = 64'h43DFFF8003FFFFFF; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'hC55FFF8003FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"879247\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBCA0000000000001; + z = 64'h37F00200FFFFFFFF; + ans = 64'hBC80000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"879861\n"); + end + x = 64'h001FB1D966CCDFCE; + y = 64'hBFC4E6F76095C1F4; + z = 64'h1B73746C9DC04BF1; + ans = 64'h1B73746C9DC04BF1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"880475\n"); + end + x = 64'h3D2FFFF820000000; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"881089\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC3FFFFFDFFFFF7FF; + z = 64'h3FE0000800FFFFFE; + ans = 64'hC3DFFFFDFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"881703\n"); + end + x = 64'h43D3000000000000; + y = 64'hBFD0000000000000; + z = 64'hB7E7428087FE7255; + ans = 64'hC3B3000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"882317\n"); + end + x = 64'h3FD0000000000000; + y = 64'h43CCB81C98B1BC94; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"882931\n"); + end + x = 64'h3FD4A71E4A6E4C00; + y = 64'h3FBFFFFFFFFFFDF6; + z = 64'h000FFFFFFF7FFE00; + ans = 64'h3FA4A71E4A6E4AAF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"883545\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hBFBFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"884159\n"); + end + x = 64'hBCA00004000003FF; + y = 64'h499FFFFFFFFFE800; + z = 64'h4010000000000000; + ans = 64'hC6500003FFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"884773\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBFE0000000000000; + z = 64'hC2BFFFFFFBBFFFFF; + ans = 64'hC2BFFFFFFBC0001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"885387\n"); + end + x = 64'hBCAFDFFFFFFFEFFF; + y = 64'hBFEFBFFFFEFFFFFF; + z = 64'h3819477BBAEEBE75; + ans = 64'h3CAFA03FFF00F01E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"886001\n"); + end + x = 64'hBFEFFFFFFBFFFFBE; + y = 64'hBFE0000000000001; + z = 64'hBFD0000000000000; + ans = 64'h3FCFFFFFF7FFFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"886615\n"); + end + x = 64'h3FD0000000000000; + y = 64'h3F71F00000000000; + z = 64'h001C00000000003F; + ans = 64'h3F51F00000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"887229\n"); + end + x = 64'h3180000800000000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h4010008000003FFF; + ans = 64'h4010008000003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"887843\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBFAFFFFFFFFF7BFF; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"888457\n"); + end + x = 64'h00299FE07104D6A3; + y = 64'h3B7007FFFFFFEFFE; + z = 64'h43DFFFFFF0001000; + ans = 64'h43DFFFFFF0001000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"889071\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBFF0000000000001; + z = 64'h8000000000000000; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"889685\n"); + end + x = 64'h3FCF4D325CFDD93C; + y = 64'h0016A743D6888DB5; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"890299\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hC0169EAB4642D2BE; + ans = 64'hC0189EAB4642D2BE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"890913\n"); + end + x = 64'h449FFFFFDDFFFFFE; + y = 64'h3E4FFFFB7FFFFFFF; + z = 64'h3FB0EE0C1F0EC5E3; + ans = 64'h42FFFFFB5E0004C6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"891527\n"); + end + x = 64'hC03FFFE000000001; + y = 64'hC000000000000000; + z = 64'hBCA0000000000001; + ans = 64'h404FFFE000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"892141\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC00000004FFFFFFE; + z = 64'h40D0000000080100; + ans = 64'h40CFFFC0000EC200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"892755\n"); + end + x = 64'hBFA001FFFFFFC000; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h47E0FC03BF40CC75; + ans = 64'h47E0FC03BF40CC75; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"893369\n"); + end + x = 64'h3FD0000000000000; + y = 64'h002000000FFFFFF7; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"893983\n"); + end + x = 64'h4110000A00000000; + y = 64'h59BF221FD8F50EDA; + z = 64'h43F03FFFFFFFF7FF; + ans = 64'h5ADF22334E48F673; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"894597\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC010000000000000; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"895211\n"); + end + x = 64'hC12FFFFFFFE00000; + y = 64'hC3EFFEFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h452FFEFFFFE000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"895825\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hC5BEEB8D6F57D560; + ans = 64'hC5BEEB8D6F57D560; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"896439\n"); + end + x = 64'h3CAFFFBFFFFFDFFF; + y = 64'hC1C5DE58051F8BE2; + z = 64'hC0E000000003FFBE; + ans = 64'hC0E0000000045737; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"897053\n"); + end + x = 64'h3F2FFFFFFFFDF7FE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'hBF5FFFFFFFFDF7FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"897667\n"); + end + x = 64'h3FD0000000000000; + y = 64'h404001D305E5077D; + z = 64'h43E345C0BA2B4702; + ans = 64'h43E345C0BA2B4702; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"898281\n"); + end + x = 64'h400FFEFFFFFEFFFF; + y = 64'hC340000000000001; + z = 64'hBFC8084BF0E72845; + ans = 64'hC35FFEFFFFFF0001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"898895\n"); + end + x = 64'h3FD0000000000000; + y = 64'h451FC0FFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'h44FFC0FFFBFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"899509\n"); + end + x = 64'h43AFFFFFBFFFFFFB; + y = 64'h801000001FFBFFFF; + z = 64'h41DFFFFFFFFFFFCE; + ans = 64'h41DFFFFFFFFFFFCE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"900123\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"900737\n"); + end + x = 64'h6BFFFFBFFFFFFFFC; + y = 64'h283FFFFFFDFBFFFF; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h544FFFBFFDFC0403; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"901351\n"); + end + x = 64'h3FD0000000000000; + y = 64'hFFE0000000000000; + z = 64'h161FFFFFFFDFFFFF; + ans = 64'hFFC0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"901965\n"); + end + x = 64'h37F2080000000000; + y = 64'h3FCEFFFFFFFFFFFF; + z = 64'h4340000000420000; + ans = 64'h4340000000420000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"902579\n"); + end + x = 64'hB92000FFFF7FFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h792000FFFF7FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"903193\n"); + end + x = 64'h3FD0000000000000; + y = 64'hFFDBC6970DE3B50D; + z = 64'h40683D253D82068E; + ans = 64'hFFBBC6970DE3B50D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"903807\n"); + end + x = 64'h41DFE00000003FFF; + y = 64'hFFF0000000000000; + z = 64'h3E2044A8CC924DF6; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"904421\n"); + end + x = 64'h3FD0000000000000; + y = 64'h37FC1EB686A59815; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"905035\n"); + end + x = 64'h3E400002FFFFFFFF; + y = 64'h381FFFFF40000000; + z = 64'hBE7403C848DDC703; + ans = 64'hBE7403C848DDC703; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"905649\n"); + end + x = 64'h3FD0000000000000; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"906263\n"); + end + x = 64'h3FE23B78B59A3A59; + y = 64'hB8100E2F27603D95; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"906877\n"); + end + x = 64'h3FD0000000000000; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h000000200000001E; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"907491\n"); + end + x = 64'h41CFFFC0000FFFFE; + y = 64'h43CFF7FFFFFFEFFF; + z = 64'hBF89D89F52C2F13F; + ans = 64'h45AFF7C0100FEBFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"908105\n"); + end + x = 64'h47F9AA99D39DD7D8; + y = 64'h0000000000000001; + z = 64'h8000000000000000; + ans = 64'h04D9AA99D39DD7D8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"908719\n"); end x = 64'h3FD0000000000001; - y = 64'hC000000000000000; + y = 64'hE3D0000000017FFE; + z = 64'h43EFC00000001FFF; + ans = 64'hE3B0000000017FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"909333\n"); + end + x = 64'hFFDFFE0000003FFE; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3FCFFFFFF6000000; + ans = 64'hBFFBFE0001403FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"909947\n"); + end + x = 64'h3FD0000000000001; + y = 64'hC1DFDFFFFFFFFFBE; + z = 64'hC010000000000000; + ans = 64'hC1BFE00003FFFFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"910561\n"); + end + x = 64'h3CA80FFFFFFFFFFE; + y = 64'hB7EAF87E635B0699; + z = 64'h3F5000000007FFF8; + ans = 64'h3F5000000007FFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"911175\n"); + end + x = 64'h3FD0000000000001; + y = 64'h0010000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"911789\n"); + end + x = 64'hBFBFFFFFFFEFFFDF; + y = 64'hBE92E82AF51517D5; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000025D055EB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"912403\n"); + end + x = 64'h3FD0000000000001; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hBCA007FFFFFFFFFF; + ans = 64'hBCA007FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"913017\n"); + end + x = 64'hC34FFFFFFE002000; + y = 64'h2E88C0F902659DDC; + z = 64'hB1AFFFFDFBFFFFFE; + ans = 64'hB1EAC0F8E099A70D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"913631\n"); + end + x = 64'hC7E003FFFFBFFFFF; + y = 64'h3CA0000000000000; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"914245\n"); + end + x = 64'h3FD0000000000001; + y = 64'hB5DF393CDBFD0E56; + z = 64'h2FF001EFFFFFFFFF; + ans = 64'hB5BF393CDBFD0E58; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"914859\n"); + end + x = 64'h7FF000000FFFFDFF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC02FB1C8D71620A8; + ans = 64'h7FF800000FFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"915473\n"); + end + x = 64'h3FD0000000000001; + y = 64'h3D80000040020000; + z = 64'hC000000000000001; + ans = 64'hBFFFFFFFFFFFF802; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"916087\n"); + end + x = 64'hC01B8BE39B34B0D4; + y = 64'hBFE02000000007FE; + z = 64'h41D000000000803F; + ans = 64'h41D0000000DE981A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"916701\n"); + end + x = 64'h3FD0000000000001; + y = 64'h3FD0000000000000; + z = 64'h4010000000000001; + ans = 64'h4010400000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"917315\n"); + end + x = 64'hBCA00FFFFFFFFFFE; + y = 64'h4FEFFFFFFFFFDDFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hCCA00FFFFFFFEEEC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"917929\n"); + end + x = 64'h3FD0000000000001; + y = 64'h3FD0000000000001; + z = 64'h3FCF035416EA0254; + ans = 64'h3FD381AA0B75012B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"918543\n"); + end + x = 64'hBB20000000000800; + y = 64'h3800000008400000; + z = 64'h4340000090000000; + ans = 64'h4340000090000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"919157\n"); + end + x = 64'h47F000000001F800; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"919771\n"); + end + x = 64'h3FD0000000000001; + y = 64'h4000010003FFFFFF; + z = 64'h347FFFFFFFE00004; + ans = 64'h3FE0010004000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"920385\n"); + end + x = 64'h41D56D000350CB1C; + y = 64'h3FE0000000000000; + z = 64'h405D74B8307164A8; + ans = 64'h41C56D003E3A3B7D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"920999\n"); + end + x = 64'h3FD0000000000001; + y = 64'hC00000FFFFFFFFC0; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hC004003FFFFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"921613\n"); + end + x = 64'h3CACF1F103A120CF; + y = 64'h47BFFFBFFFFFC000; + z = 64'hC2E3FEFFFFFFFFFF; + ans = 64'h447CF1B715BF5FA9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"922227\n"); + end + x = 64'h3FD0000000000001; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h4010FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"922841\n"); + end + x = 64'hCE40000000000210; + y = 64'h3FEFF81FFFFFFFFF; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'hCE3FF8200000041E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"923455\n"); + end + x = 64'h3FD0000000000001; + y = 64'h3FF0000000000000; + z = 64'h0452200000000000; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"924069\n"); + end + x = 64'h3F80000200000FFF; + y = 64'h3810000000FFE000; + z = 64'h43EB023AC93CBEFB; + ans = 64'h43EB023AC93CBEFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"924683\n"); + end + x = 64'h400AE69468F30B18; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h4350000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"925297\n"); + end + x = 64'h3FD0000000000001; + y = 64'h47FFFDFFFFFFF7FF; + z = 64'hBFEFF0000000001F; + ans = 64'h47DFFDFFFFFFF801; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"925911\n"); + end + x = 64'hC7FFFFFFFFF000FE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h7FE129213A6A1E19; + ans = 64'h7FE129213A6A1E19; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"926525\n"); + end + x = 64'h3FD0000000000001; + y = 64'h41F1FFFFFF800000; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h41D1FFFFFF400001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"927139\n"); + end + x = 64'h43FFFFFFFFFFFFFF; + y = 64'hBFFF7027F837860A; + z = 64'h38100100000FFFFF; + ans = 64'hC40F7027F8378609; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"927753\n"); + end + x = 64'h3FD0000000000001; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h4007FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"928367\n"); + end + x = 64'hB7000000201FFFFE; + y = 64'h403C000080000000; + z = 64'h0010000000000000; + ans = 64'hB74C0000B83800FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"928981\n"); + end + x = 64'h3FD0000000000001; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFDEFFF; + ans = 64'h3FF7FFFFFFFF7C00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"929595\n"); + end + x = 64'h41EFFFFFFFFFE03F; + y = 64'hC3F0800000010000; + z = 64'h4000000000000006; + ans = 64'hC5F080000000EFA0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"930209\n"); + end + x = 64'hBFD04D24C5BAD8C9; + y = 64'h4010000000000001; z = 64'h4340000000000000; ans = 64'h433FFFFFFFFFFFFF; rn = 1; @@ -22456,106 +71289,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"960677\n"); - end - x = 64'hBFCFFC0FFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h38100000FFFFFFFC; - ans = 64'h3FEFFC0FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"962691\n"); - end - x = 64'hBFDAF002AF16C261; - y = 64'h47EE313B7466FE84; - z = 64'hBAB00000203FFFFF; - ans = 64'hC7D96A7414C320EA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"964705\n"); + $fwrite(fp,"930823\n"); end x = 64'h3FD0000000000001; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + y = 64'h43EFFBFFFFFFFFF7; + z = 64'h4FBFBFC000000000; + ans = 64'h4FBFBFC000000000; rn = 1; rz = 0; rm = 0; @@ -22597,12 +71336,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"966719\n"); + $fwrite(fp,"931437\n"); end - x = 64'hC3CFFFFFFFFBFFBF; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'h43D0ED5944B60C56; - ans = 64'h472FFFFFFFFBFFBF; + x = 64'h2106EEC68B20AD3B; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h8013FFFE00000000; + ans = 64'h2136EEC68B20AD3A; rn = 1; rz = 0; rm = 0; @@ -22644,59 +71383,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"968733\n"); - end - x = 64'hB796FC9D90A9E784; - y = 64'hBF000000FEFFFFFE; - z = 64'h3E1954561DD3AD12; - ans = 64'h3E1954561DD3AD12; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"970747\n"); + $fwrite(fp,"932051\n"); end x = 64'h3FD0000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hFFD0000000000000; + y = 64'hB8CFFFDFFDFFFFFF; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; rn = 1; rz = 0; rm = 0; @@ -22738,12 +71430,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"972761\n"); + $fwrite(fp,"932665\n"); end - x = 64'h381000000000081F; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'hC3DFFFFFBFFFFFEF; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h7FF00001FFFFFF7F; + y = 64'h43EFFF7FBFFFFFFF; + z = 64'hC09FFFFFDFFFFF80; + ans = 64'h7FF80001FFFFFF7F; rn = 1; rz = 0; rm = 0; @@ -22785,623 +71477,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"974775\n"); + $fwrite(fp,"933279\n"); end - x = 64'h3C300000FFFFF7FF; - y = 64'hC2BFFF0000000004; - z = 64'hBFCBFB075CA1326A; - ans = 64'hBFCBFC0754B131EA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"976789\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"978803\n"); - end - x = 64'h402FFFFE0FFFFFFF; - y = 64'h0010000000000001; - z = 64'hCF771A48F1DEC87F; - ans = 64'hCF771A48F1DEC87F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"980817\n"); - end - x = 64'hCC300000800003FF; - y = 64'h47A001000001FFFF; - z = 64'hC3F220870AB7024F; - ans = 64'hD3E00100800A03FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"982831\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"984845\n"); - end - x = 64'hC0F0E9718D9CDCE9; - y = 64'h3FD0000000000001; - z = 64'hC01FFFFFFFFFFEFD; - ans = 64'hC0D0EB718D9CDCEA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"986859\n"); - end - x = 64'h67900003FFFFFC00; - y = 64'hC1FFFFFFFFEFDFFF; - z = 64'hB7FFFEFFFFFFFFFF; - ans = 64'hE9A00003FFF7EBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"988873\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"990887\n"); - end - x = 64'h47E0400007FFFFFF; - y = 64'h3FF0000000000001; - z = 64'hC1F9C1069A1BB125; - ans = 64'h47E0400008000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"992901\n"); - end - x = 64'hBFDFC0007FFFFFFF; - y = 64'h403FFFFFE00FFFFF; - z = 64'hEAA0000000020001; - ans = 64'hEAA0000000020001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"994915\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"996929\n"); - end - x = 64'hBFFFFC03FFFFFFFF; - y = 64'h4010000000000000; - z = 64'hC23FDF0000000000; - ans = 64'hC23FDF000007FF01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"998943\n"); - end - x = 64'hBFFFFFFFFFFFFFF6; - y = 64'hC000000000803FFE; - z = 64'h43C2000000400000; - ans = 64'h43C2000000400000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1000957\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; + x = 64'h3FD0000000000001; y = 64'h4340000000000001; - z = 64'hBFF0000000000001; - ans = 64'h432FFFFFFFFFFFFF; + z = 64'h3FF0000000000000; + ans = 64'h4320000000000004; rn = 1; rz = 0; rm = 0; @@ -23443,1703 +71524,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1002971\n"); + $fwrite(fp,"933893\n"); end - x = 64'h37FFFEFFFFFFFFDF; - y = 64'h7FE0000000000000; - z = 64'h4BEE25EB66CB8EF7; - ans = 64'h77EFFEFFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1004985\n"); - end - x = 64'hBED003FFC0000000; - y = 64'hC00FFDFFFFFEFFFE; - z = 64'hBF4FFFFFFBFFFFF7; - ans = 64'hBF4F7FE7FFFFE3F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1006999\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'h7FF0000000000001; - z = 64'h4340000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1009013\n"); - end - x = 64'hFFDFFFF8000003FE; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'h4070000801FFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1011027\n"); - end - x = 64'hFFE000000001001F; - y = 64'h434FFBFFEFFFFFFF; - z = 64'hBFFFFFFFFE007FFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1013041\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'h8010000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1015055\n"); - end - x = 64'hC080000000201000; - y = 64'h801FFFFFFFFFFFFE; - z = 64'h41CFFDFFFFFFFFFE; - ans = 64'h41CFFDFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1017069\n"); - end - x = 64'h380FFFFFF0000010; - y = 64'h801FFFFFFFFC000E; - z = 64'hC00FFFF7FFFFFFFE; - ans = 64'hC00FFFF7FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1019083\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'hBFD0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBFC0000000000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1021097\n"); - end - x = 64'hB7E0000000007FBF; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'h41EFFFFFF00003FF; - ans = 64'h41EFFFFFF00003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1023111\n"); - end - x = 64'hB92FFFDFC0000000; - y = 64'h8020000000100006; - z = 64'hBF74CFAB3BCC97F9; - ans = 64'hBF74CFAB3BCC97F9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1025125\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'hBFF0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FE0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1027139\n"); - end - x = 64'hDBA7D78F351ECD8C; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h3FD0001FFFFFFDFF; - ans = 64'h5BB7D78F351ECD8B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1029153\n"); - end - x = 64'hA19FFFF7FF7FFFFF; - y = 64'hBD0E000010000000; - z = 64'hC03FFFFFFBFE0000; - ans = 64'hC03FFFFFFBFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1031167\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1033181\n"); - end - x = 64'h9A66ECD450DBEE9F; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h7FE0000000005FFF; - ans = 64'h7FE0000000005FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1035195\n"); - end - x = 64'hB81F7FFFFFFFDFFF; - y = 64'hC800000100000000; - z = 64'h6CB1FFFFFFBFFFFE; - ans = 64'h6CB1FFFFFFBFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1037209\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1039223\n"); - end - x = 64'hB801EB65455027DA; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hFFEFFFC000001000; - ans = 64'hFFEFFFC000001000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1041237\n"); - end - x = 64'h3F700000003FDFFF; - y = 64'hBCA0000000007FDF; - z = 64'hBF50400000007FFF; - ans = 64'hBF50400000008001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1043251\n"); - end - x = 64'h3FDFFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1045265\n"); - end - x = 64'hB7FDFBFFFFFFFFFE; - y = 64'h0000000000000001; - z = 64'h7FD000000000203F; - ans = 64'h7FD000000000203F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1047279\n"); - end - x = 64'h3FF7FFFFFFFEFFFF; - y = 64'h38700003FFFFF800; - z = 64'h4120000FFFFFFBFF; - ans = 64'h4120000FFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1049293\n"); - end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1051307\n"); - end - x = 64'hBFEFFF7FFFFBFFFF; - y = 64'h3CA0000000000001; - z = 64'hC740080000000FFE; - ans = 64'hC740080000000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1053321\n"); - end - x = 64'h43DFFFFFFFFE0002; - y = 64'h480F9A103B845795; - z = 64'h403000007FFFFFDF; - ans = 64'h4BFF9A103B825DF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1055335\n"); - end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1057349\n"); - end - x = 64'h3FAB095E19BC680A; - y = 64'h3FE0000000000000; - z = 64'hBE74000000010000; - ans = 64'h3F9B095919BC680A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1059363\n"); - end - x = 64'h34AAE4B683C5F934; - y = 64'h47E4010000000000; - z = 64'h403FFFFFFFE00010; - ans = 64'h403FFFFFFFE00010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1061377\n"); - end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'h3FF0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1063391\n"); - end - x = 64'hBFF7C5CB22453387; - y = 64'h4000000000000000; - z = 64'h7FFAF9FF7BFE0B10; - ans = 64'h7FFAF9FF7BFE0B10; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1065405\n"); - end - x = 64'hC18000000F000000; - y = 64'h488000000000FFFE; - z = 64'h41C010003FFFFFFE; - ans = 64'hCA1000000F00FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1067419\n"); - end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'h4010000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1069433\n"); - end - x = 64'h37F512CCFA31FCDB; - y = 64'h4340000000000000; - z = 64'h800FFFFFFE800000; - ans = 64'h3B4512CCFA31FCDB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1071447\n"); - end - x = 64'hC040010000020000; - y = 64'hBFF00000100000FE; - z = 64'h3FD5CA5E3CB16DF4; - ans = 64'h40402C94CC7C63DA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1073461\n"); - end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'h7FE0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h7FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1075475\n"); - end - x = 64'h43EDD3E4302B9937; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hB7E8380CF656C23A; + x = 64'h407E7C49B84A1813; + y = 64'h7FEC9DC7A22C5F2A; + z = 64'h0000000000000001; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -25182,12 +71571,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1077489\n"); + $fwrite(fp,"934507\n"); end - x = 64'h403000200001FFFF; - y = 64'h43EFFFFFFFFFFFFE; - z = 64'hC1EFF7DFFFFFFFFF; - ans = 64'h443000200001003F; + x = 64'h3FD0000000000001; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hC66000008000001F; + ans = 64'hC66000008000001D; rn = 1; rz = 0; rm = 0; @@ -25229,12 +71618,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1079503\n"); + $fwrite(fp,"935121\n"); end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'h8000000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + x = 64'h3E70FFFFFF000000; + y = 64'h400FFF8100000000; + z = 64'h426000100001FFFF; + ans = 64'h426000100001FFFF; rn = 1; rz = 0; rm = 0; @@ -25276,12 +71665,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1081517\n"); + $fwrite(fp,"935735\n"); end - x = 64'hBCCFFFFFFEFFFBFF; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h402155B78FBF3A15; - ans = 64'h402155B78FBF3A15; + x = 64'hBDDBFFFFFEFFFFFF; + y = 64'h7FE0000000000000; + z = 64'h4010000000000001; + ans = 64'hFDCBFFFFFEFFFFFF; rn = 1; rz = 0; rm = 0; @@ -25323,12 +71712,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1083531\n"); + $fwrite(fp,"936349\n"); end - x = 64'hDBD0007FFFFF7FFF; - y = 64'h3F827A8892CBAFE7; - z = 64'h401000000000005E; - ans = 64'hDB627B1C670FB26F; + x = 64'h3FD0000000000001; + y = 64'h4344EFFCAA357859; + z = 64'h3CAFFF000000007E; + ans = 64'h4324EFFCAA35785A; rn = 1; rz = 0; rm = 0; @@ -25370,11 +71759,340 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1085545\n"); + $fwrite(fp,"936963\n"); end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'hBCA0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; + x = 64'hBFA1E04D77711DA5; + y = 64'h7FE0000000000001; + z = 64'h37E79B4E706CAB4B; + ans = 64'hFF91E04D77711DA6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"937577\n"); + end + x = 64'h3FD0000000000001; + y = 64'hB81000080000001E; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"938191\n"); + end + x = 64'h41FFFE8000000000; + y = 64'h3FCFFF7FFFDFFFFF; + z = 64'hF61FFC8000000000; + ans = 64'hF61FFC8000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"938805\n"); + end + x = 64'h3FD0000000000001; + y = 64'h7FF0000000000000; + z = 64'h3FE0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"939419\n"); + end + x = 64'h3FC287A64DA52860; + y = 64'h1C903FFFFFC00000; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"940033\n"); + end + x = 64'h3FD0000000000001; + y = 64'h7FF0000000000001; + z = 64'hBCA82E7990B52CC4; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"940647\n"); + end + x = 64'hC010000003FBFFFF; + y = 64'hC7E38964973306D4; + z = 64'hB80004FFFFFFFFFE; + ans = 64'h480389649C107D9F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"941261\n"); + end + x = 64'h3DE46B9905A7DCC3; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFF; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -25417,12 +72135,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1087559\n"); + $fwrite(fp,"941875\n"); end - x = 64'hB8BFFFFFFFF00040; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'hC29D554AC7605657; - ans = 64'hC29D554AC7605657; + x = 64'h3FD0000000000001; + y = 64'h7FF0EF17815B5D60; + z = 64'h15AC93DCB8E5466F; + ans = 64'h7FF8EF17815B5D60; rn = 1; rz = 0; rm = 0; @@ -25464,12 +72182,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1089573\n"); + $fwrite(fp,"942489\n"); end - x = 64'h36E00000000FFF00; - y = 64'h3FE0000100000006; - z = 64'hC3FFFEFE00000000; - ans = 64'hC3FFFEFE00000000; + x = 64'h80102FFFFFFFFFFF; + y = 64'h8000000000000000; + z = 64'hB7EFFFFF5FFFFFFF; + ans = 64'hB7EFFFFF5FFFFFFF; rn = 1; rz = 0; rm = 0; @@ -25511,574 +72229,10 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1091587\n"); + $fwrite(fp,"943103\n"); end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'hBFE0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hBFCFFFFFFFFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1093601\n"); - end - x = 64'hC1D000008000003F; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'h377FFFFFFFFFFF5E; - ans = 64'h41D000008000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1095615\n"); - end - x = 64'hBCE000000001FC00; - y = 64'h3FF80CABB0668B82; - z = 64'hB9FFFFFFFCFFFFFF; - ans = 64'hBCE80CABB0698754; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1097629\n"); - end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1099643\n"); - end - x = 64'h434FFFFFFB800000; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h3B0FFFDFEFFFFFFE; - ans = 64'hC36FFFFFFB7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1101657\n"); - end - x = 64'h3FCFBFFFFFFFDFFF; - y = 64'hF07FFE0000080000; - z = 64'h4041727FB1168149; - ans = 64'hF05FBE040007D001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1103671\n"); - end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1105685\n"); - end - x = 64'hC7E00020000007FF; - y = 64'hC340000000000001; - z = 64'h3D8081FFFFFFFFFF; - ans = 64'h4B30002000000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1107699\n"); - end - x = 64'hBFE0D3B25C7B97A9; - y = 64'hC045BACF43664564; - z = 64'hB7F7D9E75B6702EA; - ans = 64'h4036DA510C8AE9BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1109713\n"); - end - x = 64'h3FDFFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1111727\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'hFFF0000000000001; - z = 64'h402207E547F7FB2F; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1113741\n"); - end - x = 64'hB80FFFFFFFFF001E; - y = 64'h593FFC07FFFFFFFF; - z = 64'h41C00000000007EF; - ans = 64'hD15FFC07FFFF003D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1115755\n"); - end - x = 64'h3FE0000000000000; - y = 64'h000FFFFFFFFFFFFF; + x = 64'h3FD0000000000001; + y = 64'h800363A5C355B338; z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; @@ -26122,12 +72276,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1117769\n"); + $fwrite(fp,"943717\n"); end - x = 64'h47EFFFF100000000; - y = 64'h0010000000000001; - z = 64'hBFBFFFBFFFFFFFBF; - ans = 64'hBFBFFFBFFFFFFFBF; + x = 64'h388238397A22857F; + y = 64'hBCCDFFFBFFFFFFFE; + z = 64'hBFBBFFFFF8000000; + ans = 64'hBFBBFFFFF8000000; rn = 1; rz = 0; rm = 0; @@ -26169,12 +72323,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1119783\n"); + $fwrite(fp,"944331\n"); end - x = 64'hBFE2000400000000; - y = 64'hC3C0000000FFFFFE; - z = 64'hC01FFFF7FFFFFF7F; - ans = 64'h43B200040120003E; + x = 64'h3FD0000000000001; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -26216,12 +72370,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1121797\n"); + $fwrite(fp,"944945\n"); end - x = 64'h3FE0000000000000; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; + x = 64'h41AFFFFFFFBF7FFF; + y = 64'hC0091C99F8B11DCA; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -26263,670 +72417,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1123811\n"); + $fwrite(fp,"945559\n"); end - x = 64'h3CAAA1E923207153; - y = 64'h3FD0000000000000; - z = 64'hAC0F2FA413460742; - ans = 64'h3C8AA1E923207153; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1125825\n"); - end - x = 64'h381FFFFFFFC03FFF; - y = 64'h3FCFFFFFFFFFE1FE; - z = 64'h220000000003FF00; - ans = 64'h37FFFFFFFFC021FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1127839\n"); - end - x = 64'h3FE0000000000000; - y = 64'h3FE0000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1129853\n"); - end - x = 64'hC1F000000401FFFF; - y = 64'h3FF0000000000000; - z = 64'h41D0060DA9F8C199; - ans = 64'hC1E7FCF933079F32; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1131867\n"); - end - x = 64'hB3D020000007FFFE; - y = 64'h2EBFFFFFFC000004; - z = 64'h43F0000001DFFFFF; - ans = 64'h43F0000001DFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1133881\n"); - end - x = 64'h3FE0000000000000; - y = 64'h4000000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1135895\n"); - end - x = 64'h400FFFFF7F800000; - y = 64'h4010000000000000; - z = 64'h3FE0000000400000; - ans = 64'h40307FFFBFC20000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1137909\n"); - end - x = 64'h3F0FFBE000000000; - y = 64'hBFDFFFFFDFFFFFFF; - z = 64'hC67DFFFFFFFFC000; - ans = 64'hC67DFFFFFFFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1139923\n"); - end - x = 64'h3FE0000000000000; - y = 64'h4340000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h4330000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1141937\n"); - end - x = 64'h2A50000000107FFF; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hC32FFFFE01000000; - ans = 64'hC32FFFFE01000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1143951\n"); - end - x = 64'hC010003F7FFFFFFE; - y = 64'hA5EFFFFFFFF80000; - z = 64'h4520000DFFFFFFFE; - ans = 64'h4520000DFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1145965\n"); - end - x = 64'h3FE0000000000000; - y = 64'h7FF0000000000000; - z = 64'hBFF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1147979\n"); - end - x = 64'hBF25A31B8EC1FFCC; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hC27ECDE37A041576; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1149993\n"); - end - x = 64'hC01B7FFFFFFFFFFF; - y = 64'h3FD2A7929E3D480E; - z = 64'h3CA0000008200000; - ans = 64'hC0000801FFFCA9EB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1152007\n"); - end - x = 64'h3FE0000000000000; + x = 64'h3FD0000000000001; y = 64'h8010000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + z = 64'h3CA814604180F249; + ans = 64'h3CA814604180F249; rn = 1; rz = 0; rm = 0; @@ -26968,12 +72464,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1154021\n"); + $fwrite(fp,"946173\n"); end - x = 64'hBFFFFFFF80000040; + x = 64'h3FCFFF80001FFFFF; + y = 64'h3FECEAFB782ECD40; + z = 64'hC3D9BA4276C0833E; + ans = 64'hC3D9BA4276C0833E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"946787\n"); + end + x = 64'h64A007F7FFFFFFFF; y = 64'h801FFFFFFFFFFFFF; - z = 64'h3FB000008000001E; - ans = 64'h3FB000008000001E; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -27015,12 +72558,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1156035\n"); + $fwrite(fp,"947401\n"); end - x = 64'hC34FBFFFFFFFF7FE; - y = 64'h40100000001FFFBE; - z = 64'h406814B7CD412DEC; - ans = 64'hC36FC000003F7763; + x = 64'h3FD0000000000001; + y = 64'h380FFFFFFFFFFFEF; + z = 64'hC01FFFFFBFFFFFBF; + ans = 64'hC01FFFFFBFFFFFBF; rn = 1; rz = 0; rm = 0; @@ -27062,10 +72605,1843 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1158049\n"); + $fwrite(fp,"948015\n"); end - x = 64'h3FE0000000000000; + x = 64'hA5D382EB96AD50AD; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hC5300000FFFFF800; + ans = 64'hC5300000FFFFF800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"948629\n"); + end + x = 64'h3FD0000000000001; + y = 64'h3FCFFFFFFFFBFFFF; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h3FAFFFFFFFFC0001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"949243\n"); + end + x = 64'h400FFFFFFE000200; + y = 64'hC7E08000000003FF; + z = 64'hC030000000003FF0; + ans = 64'hC8007FFFFEF80507; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"949857\n"); + end + x = 64'h3FD0000000000001; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CA7FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"950471\n"); + end + x = 64'h3FFFFFFFFFF80FFF; + y = 64'hC3F0000000000081; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"951085\n"); + end + x = 64'h3FD0000000000001; y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h002F0003FFFFFFFF; + ans = 64'hBC90000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"951699\n"); + end + x = 64'hBFBFFFFFFFFFFFFF; + y = 64'h00100000000001F7; + z = 64'h37FFFEFFFFFFFEFF; + ans = 64'h37FFFEFFFFFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"952313\n"); + end + x = 64'h3E771CF6C17F0752; + y = 64'hBFD0000000000001; + z = 64'h3FF0000000000000; + ans = 64'h3FEFFFFFF471849F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"952927\n"); + end + x = 64'h3FD0000000000001; + y = 64'hBFB0008000000FFF; + z = 64'h40DB1A37D21A1798; + ans = 64'h40DB1A36D2121798; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"953541\n"); + end + x = 64'hBFDFFBFF80000000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hBFB000000007FFF0; + ans = 64'h3FC7FBFF7FFC0007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"954155\n"); + end + x = 64'h3FD0000000000001; + y = 64'hC033697E014548B4; + z = 64'h8010000000000000; + ans = 64'hC013697E014548B5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"954769\n"); + end + x = 64'hBFFA87A874A05E30; + y = 64'hC8211E73E27BE4D9; + z = 64'h53F00003FFFFFFF7; + ans = 64'h53F00003FFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"955383\n"); + end + x = 64'h3FD0000000000001; + y = 64'hBFE0000000000001; + z = 64'h3CA0000000000000; + ans = 64'hBFBFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"955997\n"); + end + x = 64'hBFDFFC3FFFFFFFFF; + y = 64'h40103FFFFFFDFFFF; + z = 64'hC340000000000001; + ans = 64'hC340000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"956611\n"); + end + x = 64'h3FD0000000000001; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBF145491BF6D4A83; + ans = 64'hBFD00145491BF6D5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"957225\n"); + end + x = 64'h408C000001FFFFFF; + y = 64'h0001FFFFFFFFFF00; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"957839\n"); + end + x = 64'h96CFFFFFFBFFFFFF; + y = 64'hBFF0000000000000; + z = 64'h3FE0000000000001; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"958453\n"); + end + x = 64'h3FD0000000000001; + y = 64'hC7F100FE84589A72; + z = 64'h3A9FFBFDFFFFFFFF; + ans = 64'hC7D100FE84589A73; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"959067\n"); + end + x = 64'hC3CE1EC5802CC41D; + y = 64'hBFF0000000000001; + z = 64'hBFFFFFF8000FFFFE; + ans = 64'h43CE1EC5802CC41F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"959681\n"); + end + x = 64'h3FD0000000000001; + y = 64'h41D0000000000400; + z = 64'h8000000000000001; + ans = 64'h41B0000000000401; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"960295\n"); + end + x = 64'h3FC0000200020000; + y = 64'hCC503FFFFFFFEFFF; + z = 64'h402BD7CA595315B7; + ans = 64'hCC2040020801F7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"960909\n"); + end + x = 64'h3FD0000000000001; + y = 64'hC000000000000000; + z = 64'h0010000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"961523\n"); + end + x = 64'h4133D265E1ABC512; + y = 64'h3806B3BED3DAFA47; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"962137\n"); + end + x = 64'h3FD0000000000001; + y = 64'hC000000000000001; + z = 64'h444FFFFFFFFE0FFF; + ans = 64'h444FFFFFFFFE0FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"962751\n"); + end + x = 64'hC7FFC00000000200; + y = 64'h374FFFFFFFFF81FF; + z = 64'h3CF99D8CF88F4CC9; + ans = 64'hBF5FBFFFFFFF1E85; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"963365\n"); + end + x = 64'hB7F000000004003E; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"963979\n"); + end + x = 64'h3FD0000000000001; + y = 64'h40301FFFFFFFFDFF; + z = 64'hB81BFFFFFFFFF000; + ans = 64'h40101FFFFFFFFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"964593\n"); + end + x = 64'hC02AB5A6C8558DF5; + y = 64'hC010000000000000; + z = 64'hC04EF71DE29A8DE5; + ans = 64'hC02105DC6913FFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"965207\n"); + end + x = 64'h3FD0000000000001; + y = 64'h8008AB84C5B2AF24; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"965821\n"); + end + x = 64'h3FB13CA24F24198A; + y = 64'h031FC7FFFFFFFFFF; + z = 64'hC7CFFDFFFFFF0000; + ans = 64'hC7CFFDFFFFFF0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"966435\n"); + end + x = 64'h3FD0000000000001; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"967049\n"); + end + x = 64'h40139F95932450BC; + y = 64'h3FCF7FFF7FFFFFFF; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC006577488D34B68; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"967663\n"); + end + x = 64'h3FD0000000000001; + y = 64'hC340000000000000; + z = 64'h002FFEFFFFFEFFFF; + ans = 64'hC320000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"968277\n"); + end + x = 64'h41EFFFFFF7FFFFFC; + y = 64'h40D000080001FFFF; + z = 64'h403EFFFDFFFFFFFF; + ans = 64'h42D00007FC0205BD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"968891\n"); + end + x = 64'hC80FFFFF6FFFFFFE; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h4B6FFFFF6FFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"969505\n"); + end + x = 64'h3FD0000000000001; + y = 64'h43D000FFF7FFFFFE; + z = 64'hBF8EFDFFFFFFFFFF; + ans = 64'h43B000FFF7FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"970119\n"); + end + x = 64'h00200000002001FF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hC7E000000000100F; + ans = 64'hC7E000000000100F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"970733\n"); + end + x = 64'h3FD0000000000001; + y = 64'h126000000002007F; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"971347\n"); + end + x = 64'h3FDFFFFFFEF00000; + y = 64'hC01010000000000F; + z = 64'h3FEFFFFFFFFDFBFF; + ans = 64'hBFF01FFFFEEFF21E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"971961\n"); + end + x = 64'h3FD0000000000001; + y = 64'hFFE0000000000001; z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; @@ -27109,12 +74485,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1160063\n"); + $fwrite(fp,"972575\n"); end - x = 64'hC1F31745A108725D; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hC5D080007FFFFFFF; - ans = 64'hC5D080007FFFFFFF; + x = 64'h3EFFFC000000001E; + y = 64'hBFEFFFFFFFFFEDFF; + z = 64'hC000000000000000; + ans = 64'hC000000FFE000000; rn = 1; rz = 0; rm = 0; @@ -27156,12 +74532,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1162077\n"); + $fwrite(fp,"973189\n"); end - x = 64'h29FFEFFFFFC00000; - y = 64'hC1F0000000000088; - z = 64'hBFBFFFFF00003FFE; - ans = 64'hBFBFFFFF00003FFE; + x = 64'h3FD0000000000001; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h401FBFFFF7FFFFFE; + ans = 64'hFFD0000000000000; rn = 1; rz = 0; rm = 0; @@ -27203,12 +74579,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1164091\n"); + $fwrite(fp,"973803\n"); end - x = 64'h3FE0000000000000; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBFE0000000000001; + x = 64'h473FFFFF88000000; + y = 64'hB040FFFFFBFFFFFF; + z = 64'hC160000002FFFFFE; + ans = 64'hC160000002FFFFFE; rn = 1; rz = 0; rm = 0; @@ -27250,12 +74626,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1166105\n"); + $fwrite(fp,"974417\n"); end - x = 64'h400FFFFFF8000010; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h2660400000800000; - ans = 64'hC01FFFFFF800000F; + x = 64'hC1D037A403FC67CA; + y = 64'hFFF0000000000001; + z = 64'h3CA0000000000000; + ans = 64'hFFF8000000000001; rn = 1; rz = 0; rm = 0; @@ -27297,12 +74673,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1168119\n"); + $fwrite(fp,"975031\n"); end - x = 64'hC010000020FFFFFE; - y = 64'h5C80003FFFFFBFFF; - z = 64'hB8015F6E375E007E; - ans = 64'hDCA00040210043FD; + x = 64'h3FD0000000000001; + y = 64'hC7FFFFFFFFFF0040; + z = 64'hC0105563F3CA3EC6; + ans = 64'hC7DFFFFFFFFF0042; rn = 1; rz = 0; rm = 0; @@ -27344,293 +74720,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1170133\n"); + $fwrite(fp,"975645\n"); end - x = 64'h3FE0000000000000; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'hBFEFFFFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1172147\n"); - end - x = 64'h380FFE000001FFFE; - y = 64'hC010000000000001; - z = 64'hC1DF802000000000; - ans = 64'hC1DF802000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1174161\n"); - end - x = 64'h42C008FFFFFFFFFE; - y = 64'hC0200008001FFFFF; - z = 64'h43EFFFF5FFFFFFFF; - ans = 64'h43EFFFD5EDEFF6BF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1176175\n"); - end - x = 64'h3FE0000000000000; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC350000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1178189\n"); - end - x = 64'hB7E461FC806F4A9F; - y = 64'hFFE0000000000001; - z = 64'h429FFFFFFF004000; - ans = 64'h77D461FC806F4AA0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1180203\n"); - end - x = 64'hC34FFEFE00000000; - y = 64'hBC4FEFFFFFFFFFFD; - z = 64'hC020000000000087; - ans = 64'hC01FC02202FE010E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1182217\n"); - end - x = 64'h3FE0000000000000; + x = 64'h37FFFDFFFDFFFFFF; y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; + z = 64'h53E00000047FFFFE; ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -27673,12 +74767,5464 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1184231\n"); + $fwrite(fp,"976259\n"); end - x = 64'hBFFFFFFF01FFFFFF; + x = 64'h3FD0000000000001; + y = 64'hBEAFF800001FFFFE; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"976873\n"); + end + x = 64'hC1F003DFFFFFFFFF; + y = 64'h401E15640A85ECF6; + z = 64'hC7F00080000001FF; + ans = 64'hC7F00080000001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"977487\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h0000000000000000; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"978101\n"); + end + x = 64'hBFE0000008007FFE; + y = 64'hBF3FF8000000FFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFEFFE007FFF0022; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"978715\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3E40000000400FFE; + ans = 64'h3E40000000400FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"979329\n"); + end + x = 64'hBEE07FFFFFE00000; + y = 64'hBCA971847D137B50; + z = 64'hBFDFE00001FFFFFF; + ans = 64'hBFDFE00001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"979943\n"); + end + x = 64'hC3C8F08B471AE667; + y = 64'h0010000000000000; + z = 64'h0010000000000001; + ans = 64'h83E8F08B471AE667; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"980557\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hBC1FFE0000100000; + z = 64'hBFF00001FBFFFFFF; + ans = 64'hBFF00001FBFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"981171\n"); + end + x = 64'h3FFFFFFFFFFFDEFF; + y = 64'h0010000000000001; + z = 64'hB560400007FFFFFF; + ans = 64'hB560400007FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"981785\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h39300000F8000000; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"982399\n"); + end + x = 64'hD090FFFFFFFFFFC0; + y = 64'h3FBFFFFFFFFFEFF6; + z = 64'hC02FFFFFEF000000; + ans = 64'hD060FFFFFFFFF73B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"983013\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"983627\n"); + end + x = 64'hBFF0100001FFFFFF; + y = 64'h317FFFFFFFFFFC1E; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"984241\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h3CA0000000000001; + z = 64'h3E5FFFFFFFFE0002; + ans = 64'h3E600000007F0001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"984855\n"); + end + x = 64'hBFF2502429256768; + y = 64'hC7F2ED05D0BFF7AA; + z = 64'h2B964D394AA258C9; + ans = 64'h47F5A9726DE4697B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"985469\n"); + end + x = 64'hBFC0000400000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hBC800003FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"986083\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h7FFFFF7FEFFFFFFF; + z = 64'hC00000002000FFFF; + ans = 64'h7FFFFF7FEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"986697\n"); + end + x = 64'h3FCF80003FFFFFFF; + y = 64'h3FD0000000000000; + z = 64'h4BA081FFFFFFFFFE; + ans = 64'h4BA081FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"987311\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC010202000000000; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h4017EFEFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"987925\n"); + end + x = 64'h002FC07FFFFFFFFE; + y = 64'hBC40001000020000; + z = 64'h3930000000FF7FFF; + ans = 64'h3930000000FF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"988539\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"989153\n"); + end + x = 64'hBFF57175CE514C3A; + y = 64'hAEDA36C72E77963A; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"989767\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h3FE0000000000000; + z = 64'hB81D8C6AFBEFCF8A; + ans = 64'h3FCFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"990381\n"); + end + x = 64'h3FDFC00000000006; + y = 64'h3D908358E704FD5A; + z = 64'h3CAFFFFFFF0007FF; + ans = 64'h3D8062D23536EF63; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"990995\n"); + end + x = 64'hBCB003FF7FFFFFFF; + y = 64'h3FE0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"991609\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h0007DFFFFFFFFFFE; + z = 64'h41DFFFFFDFFFE000; + ans = 64'h41DFFFFFDFFFE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"992223\n"); + end + x = 64'hBCA7FFFFFFFFFFC0; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hB3B6000000000000; + ans = 64'hBCA7FFFFFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"992837\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h38100000FDFFFFFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"993451\n"); + end + x = 64'h37F0000008000000; + y = 64'h3FDFFFFFFFF00008; + z = 64'h73300F7FFFFFFFFF; + ans = 64'h73300F7FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"994065\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h3FF0000000000001; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01DFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"994679\n"); + end + x = 64'h3C0FFFFFFFFEF7FF; + y = 64'hB4CFFFFFFFFFFFFF; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"995293\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h480FFFFFFFFFFF3E; + ans = 64'h480FFFFFFFFFFF3E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"995907\n"); + end + x = 64'h6A10000000080010; + y = 64'hC021000000000001; + z = 64'h43F0003FFFFFDFFF; + ans = 64'hEA41000000088012; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"996521\n"); + end + x = 64'h3FF0000007FFF000; + y = 64'h4000000000000000; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"997135\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC00867B6EE5CD554; + z = 64'h480FFFFFFFEFFBFF; + ans = 64'h480FFFFFFFEFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"997749\n"); + end + x = 64'h36BF0007FFFFFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h400FC00000000000; + ans = 64'h400FC00000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"998363\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h3CA0000000000240; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"998977\n"); + end + x = 64'hC02FFFFFFFFF7DFF; + y = 64'hD29FFFE1FFFFFFFF; + z = 64'hD095BF0E8082970E; + ans = 64'h52DFFFE1FFFE220E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"999591\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h4010000000000000; + z = 64'hC010000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1000205\n"); + end + x = 64'h41C03FFF7FFFFFFE; + y = 64'hC1DA356842BBA7BA; + z = 64'hBCA0000000000001; + ans = 64'hC3AA9E3D121B5440; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1000819\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hC0C3FFDFFFFFFFFF; + ans = 64'hC0C3FDDFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1001433\n"); + end + x = 64'hC1CFFE0007FFFFFF; + y = 64'h80000001FFFFFFFB; + z = 64'h3EE00001FFEFFFFF; + ans = 64'h3EE00001FFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1002047\n"); + end + x = 64'h41CFFFFFF000007F; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1002661\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFF8007FF; + z = 64'h3F25B91F0BABFF28; + ans = 64'h7FFFFFFFFF8007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1003275\n"); + end + x = 64'h40EE0A93E8691D04; + y = 64'h4340000000000001; + z = 64'hC7FFEFFFFBFFFFFF; + ans = 64'hC7FFEFFFFBFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1003889\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h7FF007FF7FFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h7FF807FF7FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1004503\n"); + end + x = 64'hC5700000003FC000; + y = 64'h583FFFDFFFFFFF7E; + z = 64'h3FCFDFFFFFFFFFFF; + ans = 64'hDDBFFFE0007F7EFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1005117\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC000000000000001; + ans = 64'h433FFFFFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1005731\n"); + end + x = 64'h47F4511545A3B643; + y = 64'hC39FFC0000010000; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'hCBA44E8B22FBA455; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1006345\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h7FE0000000000001; + z = 64'h002FFFFFFFC04000; + ans = 64'h7FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1006959\n"); + end + x = 64'h41CD1B44159CA902; + y = 64'h7FFFFFFBFFFFFFFF; + z = 64'hBFE6D13A7491C894; + ans = 64'h7FFFFFFBFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1007573\n"); + end + x = 64'h4602638FB47E42DE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1008187\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h402000000000040F; + z = 64'h41CFF7FFFDFFFFFF; + ans = 64'h41CFF7FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1008801\n"); + end + x = 64'h3C4EFFFFFFFFEFFE; + y = 64'h7FF0000000000000; + z = 64'hBEEE03FFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1009415\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h43EFFC0000001FFE; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h43DFFC0000001FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1010029\n"); + end + x = 64'hC7EFFF000007FFFF; + y = 64'h802FFFFFF0000400; + z = 64'hC3CE000001FFFFFF; + ans = 64'hC3CE000001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1010643\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1011257\n"); + end + x = 64'h3FEFFFFFFFFFE07F; + y = 64'hC3C0000002000FFE; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hC3C000000200003D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1011871\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h8000000000000000; + z = 64'h43CFC00400000000; + ans = 64'h43CFC00400000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1012485\n"); + end + x = 64'hAB85C1F0653D248E; + y = 64'hC3FFFFFFFFBE0000; + z = 64'h3FD41CD3A8479F2D; + ans = 64'h3FD41CD3A8479F2D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1013099\n"); + end + x = 64'h41DFFFF000008000; + y = 64'h8000000000000001; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1013713\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC66E09CF3AF6E013; + z = 64'h511B551EA6EE8C23; + ans = 64'h511B551EA6EE8C23; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1014327\n"); + end + x = 64'h403A4AD510299EB1; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h1BCDE79C5FF69901; + ans = 64'h1BCDE79C5FF69901; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1014941\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h5CEE79D6389C3B59; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h5CDE79D6389C3B58; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1015555\n"); + end + x = 64'hC3FFFFFFFFFF8002; + y = 64'h43CF81FFFFFFFFFF; + z = 64'hC1F0FBFFFFFFFFFF; + ans = 64'hC7DF81FFFFFF81F9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1016169\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h8010000000000001; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1016783\n"); + end + x = 64'h52B00007EFFFFFFE; + y = 64'hB80000020000003F; + z = 64'h8000000000000000; + ans = 64'hCAC00009F000FE3D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1017397\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hDB40000010003FFF; + ans = 64'hDB40000010003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1018011\n"); + end + x = 64'hAA1003FFFFFFFFBF; + y = 64'h400EFCB55B759507; + z = 64'h41E00100007FFFFF; + ans = 64'h41E00100007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1018625\n"); + end + x = 64'h3ACA98EA817AAD44; + y = 64'hBCA0000000000000; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1019239\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h8762BBDF1A21B496; + z = 64'h3810000003FBFFFF; + ans = 64'h3810000003FBFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1019853\n"); + end + x = 64'hBFF0000080008000; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hCD6FF7FFFFFC0000; + ans = 64'hCD6FF7FFFFFC0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1020467\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h4090000000000011; + z = 64'h3FD0000000000000; + ans = 64'h4080020000000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1021081\n"); + end + x = 64'hFFEFE00002000000; + y = 64'hBEAFEFFFFFFF7FFF; + z = 64'h41C1D04549226D33; + ans = 64'h7EAFD01001FE807F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1021695\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hBFD0000000000000; + z = 64'hBFE0000000000000; + ans = 64'hBFE4000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1022309\n"); + end + x = 64'hBFE0000003FDFFFF; + y = 64'hC00FFF7FFFF80000; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1022923\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFF7F0; + ans = 64'h3FFBFFFFFFFFF7F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1023537\n"); + end + x = 64'h38FFFFFFFFFDFF7E; + y = 64'h9B8004000000000F; + z = 64'h2FDFFF8000000008; + ans = 64'h2FDFFF8000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1024151\n"); + end + x = 64'h3FE00001FFFEFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hC000000000000001; + ans = 64'hC00200003FFFE001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1024765\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC1CFFF000FFFFFFE; + z = 64'h7FD8040000000000; + ans = 64'h7FD8040000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1025379\n"); + end + x = 64'hC10FFFFFFFFFFEFE; + y = 64'hBFE0000000000001; + z = 64'hFFD0003F7FFFFFFF; + ans = 64'hFFD0003F7FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1025993\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h4B05E5A08426A286; + z = 64'h3CA0000000000001; + ans = 64'h4AF5E5A08426A285; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1026607\n"); + end + x = 64'hF5E0000FFFF7FFFF; + y = 64'h4017BFFFFFFFFFFE; + z = 64'hBFB3A6B42E1910C4; + ans = 64'hF607C017BFF41FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1027221\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBFD0000000000001; + ans = 64'hBFE7FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1027835\n"); + end + x = 64'h3FBFE00007FFFFFF; + y = 64'hC01FFFFFFFFE000F; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1028449\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hBFF0000000000001; + z = 64'h3813A2BEB5826B36; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1029063\n"); + end + x = 64'h3D7FFFFFFFFDFFFD; + y = 64'hBF1A0514D4BED171; + z = 64'h401FA4D562334CE0; + ans = 64'h401FA4D562334CE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1029677\n"); + end + x = 64'hA720000FFE000000; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1030291\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hBF950025543D3C42; + z = 64'hBFDB40EC8C50107B; + ans = 64'hBFDBE8EDB6F1FA5D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1030905\n"); + end + x = 64'hBFEF000004000000; + y = 64'hC000000000000000; + z = 64'hC34FF80000000006; + ans = 64'hC34FF80000000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1031519\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h43EBFFFFFF800000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h43DBFFFFFF7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1032133\n"); + end + x = 64'h3E2400000000000F; + y = 64'h43F03213356F2EC0; + z = 64'h01B2E18AE3758A2A; + ans = 64'h42243E9802CAFA7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1032747\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1033361\n"); + end + x = 64'hC7E00FFFFEFFFFFE; + y = 64'hA0FFFFF80000007E; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1033975\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC010000000000000; + z = 64'h41CE0FFFFFFFFFFF; + ans = 64'h41CE0FFFFEFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1034589\n"); + end + x = 64'hBFE001000001FFFE; + y = 64'h41C0400000040000; + z = 64'hBDAF0000000001FF; + ans = 64'hC1B041040006083E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1035203\n"); + end + x = 64'h48000000001FBFFF; + y = 64'hC010000000000001; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hC8200000001FC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1035817\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC3F00FFFFBFFFFFE; + z = 64'hC1EFF80000200000; + ans = 64'hC3E00FFFFC1FF7FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1036431\n"); + end + x = 64'hC1D0001000000020; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBFFFFFFE000001FF; + ans = 64'h4200000FFFF00020; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1037045\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hA3700000000FFFBF; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'hA3600000000FFFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1037659\n"); + end + x = 64'hA68BFDFFFFFFFFFF; + y = 64'h43FFFFFFE000003F; + z = 64'hFFDFF7FFFFFC0000; + ans = 64'hFFDFF7FFFFFC0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1038273\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC340000000000001; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hC330000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1038887\n"); + end + x = 64'hBFE0010000007FFF; + y = 64'h3FF00003FFFFFF7F; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1039501\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h37E57439B2172858; + ans = 64'hC33FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1040115\n"); + end + x = 64'h479FFFFF0FFFFFFF; + y = 64'hBCAFFF7FFFFFFFFE; + z = 64'h3FF11E1E3AE7A649; + ans = 64'hC45FFF7F1003BFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1040729\n"); + end + x = 64'h7FD00FFFFFFF0000; + y = 64'hFFE0000000000000; + z = 64'hBFE0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1041343\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hDF70080000000006; + z = 64'hC3400000FFFF0000; + ans = 64'hDF60080000000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1041957\n"); + end + x = 64'hC034D2BDB10C9441; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h434FC0000001FFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1042571\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h43F00001FFF7FFFE; + z = 64'h0000000000000000; + ans = 64'h43E00001FFF7FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1043185\n"); + end + x = 64'hC7EFFFC007FFFFFF; + y = 64'hC2D0000000000001; + z = 64'h40000000007FFFFF; + ans = 64'h4ACFFFC008000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1043799\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hFFF0000000000000; + z = 64'h8010000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1044413\n"); + end + x = 64'h3FBF09191E8A701F; + y = 64'hB17DB7CAEE1A39D7; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1045027\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hC02FFFFFFFC0000F; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1045641\n"); + end + x = 64'h381FFFFFF8000400; + y = 64'hBD60081FFFFFFFFF; + z = 64'hA9AFFFFEFFFFFFEF; + ans = 64'hB590081FFBFDFA00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1046255\n"); + end + x = 64'hC80EEC83DDF4CD6E; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hBFD0000000000001; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1046869\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC7E0000000100007; + z = 64'h31A007FEFFFFFFFF; + ans = 64'hC7D0000000100006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1047483\n"); + end + x = 64'h47EFFEFFFFF7FFFF; y = 64'h0000000000000001; - z = 64'h41A00000100007FF; - ans = 64'h41A00000100007FF; + z = 64'h3FD007FFFFFFFFFA; + ans = 64'h3FD007FFFFFFFFFA; rn = 1; rz = 0; rm = 0; @@ -27720,12 +80266,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1186245\n"); + $fwrite(fp,"1048097\n"); end - x = 64'h2D9000000FFFFFF0; - y = 64'hBF2FFFFDFFFFFFFF; - z = 64'h3FE001007FFFFFFE; - ans = 64'h3FE001007FFFFFFE; + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h001003FFFFFFDFFF; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; rn = 1; rz = 0; rm = 0; @@ -27767,10 +80313,10538 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1188259\n"); + $fwrite(fp,"1048711\n"); + end + x = 64'hD34001FFFFEFFFFF; + y = 64'h41C2BE85AF0F08B3; + z = 64'hB6FFFFFFFDFFBFFF; + ans = 64'hD512C0DD7FB22C0D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1049325\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h8000000000000001; + ans = 64'h0007FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1049939\n"); + end + x = 64'hB7E0000000000107; + y = 64'h3BCFEF765FA7E0D8; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1050553\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h0010000000000001; + z = 64'hAE9FFE000001FFFF; + ans = 64'hAE9FFE000001FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1051167\n"); + end + x = 64'h3F5FBEFFFFFFFFFF; + y = 64'h43EFEFFFFFFFF7FF; + z = 64'hBFE0007FFBFFFFFF; + ans = 64'h435FAF207FFFF80E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1051781\n"); + end + x = 64'hC887A462950B860F; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1052395\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC7FFFFFFF003FFFE; + z = 64'h400407F04DA9C1E6; + ans = 64'hC7EFFFFFF003FFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1053009\n"); + end + x = 64'hBECBC8424E208DC2; + y = 64'h3CA0000000000000; + z = 64'h43ED932CB1DF65E5; + ans = 64'h43ED932CB1DF65E5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1053623\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hBFEFFFFF7FFEFFFE; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1054237\n"); + end + x = 64'h37E176462F866ECA; + y = 64'h3FCDFFFFFFFFEFFF; + z = 64'hC21A985D8C29A10F; + ans = 64'hC21A985D8C29A10F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1054851\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1055465\n"); + end + x = 64'h40CFFFFFFF7DFFFE; + y = 64'h41F781EC9ADCFA89; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h42D781EC9A7D7B36; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1056079\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h3FD0000000000000; + z = 64'h7FD03FFFDFFFFFFF; + ans = 64'h7FD03FFFDFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1056693\n"); + end + x = 64'h43400000100001FE; + y = 64'hBE365DEBD46ECD4E; + z = 64'hBF4FFF0FFFFFFFFE; + ans = 64'hC1865DEBEACEBBDC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1057307\n"); + end + x = 64'h380FFBFFFFF7FFFE; + y = 64'h3FD0000000000001; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h37EFFBFFFFF80000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1057921\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h3DFFFFF7FFFFFF7E; + z = 64'h7FD0000000000001; + ans = 64'h7FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1058535\n"); + end + x = 64'h3F5007FFFFFFFF80; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3C71FFFFFFFEFFFE; + ans = 64'h3F4008000000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1059149\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hB7F00002001FFFFF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1059763\n"); + end + x = 64'h480FFFFFFFFFF83F; + y = 64'hBF2FFFFFFFFFFFFE; + z = 64'h802FFFFFFFF801FF; + ans = 64'hC74FFFFFFFFFF83D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1060377\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h3FE0000000000001; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1060991\n"); + end + x = 64'h407BFFFFFFDFFFFE; + y = 64'hD3CFFFC000000080; + z = 64'h3FF0000000000000; + ans = 64'hD45BFFC7FFE000AE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1061605\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h43CABC69886420B5; + ans = 64'h43CABC69886420B5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1062219\n"); + end + x = 64'h801013FFFFFFFFFF; + y = 64'hB28C5CC5F8E8D925; + z = 64'hBFD01FFFFFFFFEFE; + ans = 64'hBFD01FFFFFFFFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1062833\n"); + end + x = 64'h4031001FFFFFFFFE; + y = 64'h3FF0000000000000; + z = 64'h8010000000000000; + ans = 64'h4031001FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1063447\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC000000010400000; + z = 64'h48040000000FFFFE; + ans = 64'h48040000000FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1064061\n"); + end + x = 64'hC3CFFFFF7FFFF800; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC34000040000003F; + ans = 64'hC3E003FFC0FFFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1064675\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC1C0400002000000; + z = 64'hC340000000000000; + ans = 64'hC340000008200001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1065289\n"); + end + x = 64'hC800F8701DDBAD16; + y = 64'hC7E0000001FFFFF7; + z = 64'h3270003FFFDFFFFF; + ans = 64'h4FF0F8701FFABB10; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1065903\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h4000000000000000; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1066517\n"); + end + x = 64'hFFE0000000BFFFFF; + y = 64'h47EFFEFF7FFFFFFF; + z = 64'h3FE0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1067131\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h4000000000000001; + z = 64'h3F5FFFF7FFFC0000; + ans = 64'h3FF007FFFDFFFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1067745\n"); + end + x = 64'h4035C9DBE1FE4CF2; + y = 64'h41EFFFF7FFFFFFFE; + z = 64'h3F8FFFFDFFFDFFFF; + ans = 64'h4235C9D66F875871; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1068359\n"); + end + x = 64'h802000007FFFFFBF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h8000000000000001; + ans = 64'h804000007FFFFFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1068973\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h401B82AFA2781976; + z = 64'h43C203FFFFFFFFFF; + ans = 64'h43C203FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1069587\n"); + end + x = 64'hC1CFFFFFFFF00001; + y = 64'h4010000000000001; + z = 64'h1C2B3ED2326B0A9D; + ans = 64'hC1EFFFFFFFF00003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1070201\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC1EFFBFFFFFFFFF7; + z = 64'hC010000000000001; + ans = 64'hC1DFFC0000FFFFF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1070815\n"); + end + x = 64'h4341FFFFFFFFFF00; + y = 64'h41B0000102000000; + z = 64'h3FA2FCF93281DA50; + ans = 64'h45020001223FFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1071429\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h4340000000000001; + ans = 64'h4340000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1072043\n"); + end + x = 64'hB7E0000FFFEFFFFF; + y = 64'hC0075D6CD888AC6C; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1072657\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h4340000000000000; + z = 64'h381B3756C7E0CEA2; + ans = 64'h432FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1073271\n"); + end + x = 64'hC7FFFF000001FFFE; + y = 64'hBFF0000100001FFF; + z = 64'h43C00000800FFFFF; + ans = 64'h47FFFF01FFF23FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1073885\n"); + end + x = 64'h3FB00000001FBFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1074499\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h80100000103FFFFF; + z = 64'h4030000010000003; + ans = 64'h4030000010000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1075113\n"); + end + x = 64'h20200003FFFFFBFF; + y = 64'h7FE0000000000000; + z = 64'hC50CBDCA372F5092; + ans = 64'h60100003FFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1075727\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hB7EF8000007FFFFF; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1076341\n"); + end + x = 64'h800E082148C2033E; + y = 64'h403604647E01C31D; + z = 64'h43E55C3E9937D71C; + ans = 64'h43E55C3E9937D71C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1076955\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h7FDFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1077569\n"); + end + x = 64'h43EEFF0000000000; + y = 64'h7FFDE1631284A2C5; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h7FFDE1631284A2C5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1078183\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hBFD000001000001F; + ans = 64'h7FDFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1078797\n"); + end + x = 64'h400A5BB8D30DC2EF; + y = 64'h4110007FFFFFE000; + z = 64'hC00FFFFE0FFFFFFF; + ans = 64'h412A5C83B0D4A2A6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1079411\n"); + end + x = 64'h402FFF7FFF7FFFFF; + y = 64'h7FF0000000000001; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1080025\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC1C043520BF4D23A; + z = 64'h31500000000001F7; + ans = 64'hC1B043520BF4D239; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1080639\n"); + end + x = 64'h403FFFFFE0200000; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h477FFFFFDFFFBFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1081253\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC1EFFFFFFBFFFF7F; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hC1DFFFFFFC7FFF7D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1081867\n"); + end + x = 64'hC1EE9E66872FC38D; + y = 64'h36C98C27589707B2; + z = 64'hD498E3DB9F1B5795; + ans = 64'hD498E3DB9F1B5795; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1082481\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h8000000000000001; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1083095\n"); + end + x = 64'hC037A9075979CBC4; + y = 64'h40518D2E789419D0; + z = 64'h3CA0000000000000; + ans = 64'hC099F45E1819C3E1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1083709\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hBF8000002000000F; + ans = 64'hBF8000002000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1084323\n"); + end + x = 64'hBFCFF0000003FFFF; + y = 64'hFFDFF7FFFFFFF000; + z = 64'h3D0FE000001FFFFF; + ans = 64'h7FBFE8040003EF07; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1084937\n"); + end + x = 64'hBFC8A912FAE0FC93; + y = 64'h8010000000000000; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1085551\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h3FEFFFBFF0000000; + z = 64'h41C2406AD1F3DEA0; + ans = 64'h41C2406AD233DE20; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1086165\n"); + end + x = 64'hB7F4FFFFFFFFFFFE; + y = 64'h8010000000000001; + z = 64'hC1C00000000400FF; + ans = 64'hC1C00000000400FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1086779\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h40500000001FBFFE; + z = 64'hBFF0000000000000; + ans = 64'h403F0000003F7FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1087393\n"); + end + x = 64'hBFB39DB3C745AB05; + y = 64'hC28FFFFFFFFFDFE0; + z = 64'hBDEFFFFFFC000800; + ans = 64'h42539DB3C7459754; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1088007\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hBCA0000000000000; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1088621\n"); + end + x = 64'hABCB70E42BF56E97; + y = 64'h43CFFF00000001FF; + z = 64'h0010000000000001; + ans = 64'hAFAB7008A4D410A2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1089235\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hBCA0000000000001; + z = 64'h3FE0000013FFFFFF; + ans = 64'h3FE0000013FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1089849\n"); + end + x = 64'hC4D03FFFFFFFFFFF; + y = 64'hE2387F5A30B75DCE; + z = 64'hC030FFFFFFFFFFDF; + ans = 64'h6718E157997A3B44; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1090463\n"); + end + x = 64'hC1CFFFFFF7FFFFF7; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1091077\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC7FFFFFFC000007F; + z = 64'hBFF4FFFFFFFFFFFF; + ans = 64'hC7EFFFFFC000007D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1091691\n"); + end + x = 64'h37500007FFFEFFFF; + y = 64'hBFD0000000000000; + z = 64'h000FFFFFF800007F; + ans = 64'hB7300007FFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1092305\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h5E30FFF000000000; + z = 64'hBFE0000000000001; + ans = 64'h5E20FFEFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1092919\n"); + end + x = 64'hC9E919F45AC84E5F; + y = 64'hBF00004000002000; + z = 64'h3FAFFFC100000000; + ans = 64'h48F91A58C299EBB4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1093533\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FE8000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1094147\n"); + end + x = 64'h47F0000000000DFF; + y = 64'h381FFC000000001E; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h401FFC0000001C19; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1094761\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hBFE0000000000000; + z = 64'hC4DFFFFFDFBFFFFE; + ans = 64'hC4DFFFFFDFBFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1095375\n"); + end + x = 64'h3FD3AD346C33E68E; + y = 64'hC1051C2D00B3BF05; + z = 64'h3FDFFFEFFFFF7FFF; + ans = 64'hC0E9F5EB41C9F664; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1095989\n"); + end + x = 64'hC3F27A392E74EC3D; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h43F27A392E74EC3C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1096603\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h381FFFFFFFFF8100; + z = 64'hC01FFFFFFFEFC000; + ans = 64'hC01FFFFFFFEFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1097217\n"); + end + x = 64'hC09FFEFFFFFFFFBF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hC0145E9928594298; + ans = 64'h409FEAA166D7A67A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1097831\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h43DFF00000000003; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h43CFF00000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1098445\n"); + end + x = 64'hBFFFFFE000000003; + y = 64'h3F0C000001FFFFFF; + z = 64'h5B60000000000100; + ans = 64'h5B60000000000100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1099059\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1099673\n"); + end + x = 64'hAC0F800000000001; + y = 64'hFFFFFFFFFDFFFFFB; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1100287\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h41FFFFFFFEFFF7FE; + ans = 64'h41FFFFFFFEEFF7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1100901\n"); + end + x = 64'hC4D21A55752A67B8; + y = 64'h3DABFFEFFFFFFFFF; + z = 64'hBE0FFFE0000FFFFF; + ans = 64'hC28FAE0372B4C056; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1101515\n"); + end + x = 64'hBFD0000000000EFF; + y = 64'hC000000000000001; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h40120000000001DF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1102129\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hFFF4E88B301CCC49; + z = 64'h41CFFFFFEFFFEFFF; + ans = 64'hFFFCE88B301CCC49; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1102743\n"); + end + x = 64'hC3DFFFF0000FFFFE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h3800007FFFFFFFC0; + ans = 64'h43FFFFF0000FFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1103357\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC03FFFFF7FDFFFFE; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hC02FFFFF7FDFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1103971\n"); + end + x = 64'hC7FFFFFFFB7FFFFF; + y = 64'h37EFFFFFFFDFFBFF; + z = 64'hC34000003FFFFFFC; + ans = 64'hC34000003FFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1104585\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC010000000000001; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'hBFF8000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1105199\n"); + end + x = 64'h40F01FFFFFFFFFF6; + y = 64'hB7FEFFFF7FFFFFFE; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1105813\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h400E000000000000; + ans = 64'hBFCFFFFFFFFFFFD0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1106427\n"); + end + x = 64'h002FFFFFFF700000; + y = 64'hB7EFFFFFFFFFDFBF; + z = 64'hB7FB7132663A42B2; + ans = 64'hB7FB7132663A42B2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1107041\n"); + end + x = 64'hBFD0008000003FFE; + y = 64'hC340000000000000; + z = 64'h4000000000000000; + ans = 64'h4320008000004002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1107655\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h3E1FFFFFFEFFF000; + z = 64'h3FEFDFFFFFFFFFFF; + ans = 64'h3FEFE000007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1108269\n"); + end + x = 64'hEAF000000000FFDF; + y = 64'hC340000000000001; + z = 64'hBF4000000023FFFE; + ans = 64'h6E4000000000FFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1108883\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h41F00007FFF7FFFE; + z = 64'hBCA0000000000000; + ans = 64'h41E00007FFF7FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1109497\n"); + end + x = 64'h802FFFFFFF7FFC00; + y = 64'hBA003FFFFE000000; + z = 64'h41F5E9BB04770872; + ans = 64'h41F5E9BB04770872; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1110111\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hFFE0000000000000; + z = 64'h3FD0000000000000; + ans = 64'hFFCFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1110725\n"); + end + x = 64'hC3EFFFFFDFC00000; + y = 64'hC0388527EF25A62F; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1111339\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hFFE0000000000001; + z = 64'hC0507FFFFFFFF800; + ans = 64'hFFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1111953\n"); + end + x = 64'h3F2000100FFFFFFF; + y = 64'hB80FFFFFFFF80100; + z = 64'hCBC0000010010000; + ans = 64'hCBC0000010010000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1112567\n"); + end + x = 64'h2FC3FEE42A17A068; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'hEFC3FEE42A17A067; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1113181\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hAC886013D8702B8D; + z = 64'h7FF0001FFFE00000; + ans = 64'h7FF8001FFFE00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1113795\n"); + end + x = 64'hC3FFFFFFFFFFFFFF; + y = 64'hFFF0000000000000; + z = 64'h54BEFFFF7FFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1114409\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC7F1FFFF80000000; + z = 64'h8010000000000001; + ans = 64'hC7E1FFFF7FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1115023\n"); + end + x = 64'h40200003FFFFDFFF; + y = 64'hB1407FFFFFEFFFFF; + z = 64'hC02008000000003F; + ans = 64'hC02008000000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1115637\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h3CA0000000000001; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1116251\n"); + end + x = 64'hBE62C38E424FE361; + y = 64'h412FFFBFFFFFFFBE; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1116865\n"); + end + x = 64'h3FE0000000000000; + y = 64'h0000000000000000; + z = 64'h000F7FFFBFFFFFFF; + ans = 64'h000F7FFFBFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1117479\n"); + end + x = 64'hC80FFFFF7FFFFFDF; + y = 64'h227C56AAB6DA3602; + z = 64'h94B4858BCE164D6E; + ans = 64'hAA9C56AA457F8B09; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1118093\n"); + end + x = 64'h43D03FFFFEFFFFFE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1118707\n"); + end + x = 64'h3FE0000000000000; + y = 64'hBFEFFFFFF8020000; + z = 64'h41EAECD3F27183B9; + ans = 64'h41EAECD3F26183B9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1119321\n"); + end + x = 64'h46CFFFFFF7FFFFFF; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h55FFFFFFFFFFF002; + ans = 64'h55FFFFFFFFFFF002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1119935\n"); + end + x = 64'h3FE0000000000000; + y = 64'hBFBFFE07FFFFFFFF; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'hBFAFFE07FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1120549\n"); + end + x = 64'h418FFFFFFFFC0100; + y = 64'h41C001FFFFDFFFFF; + z = 64'h7DB000800007FFFE; + ans = 64'h7DB000800007FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1121163\n"); + end + x = 64'h3FE0000000000000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h0027FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1121777\n"); + end + x = 64'hC7FE000400000000; + y = 64'h3FF20000000007FF; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC800E0024000077F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1122391\n"); + end + x = 64'h3FE0000000000000; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hC1F3FF7FFFFFFFFF; + ans = 64'hC1F3FF7FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1123005\n"); + end + x = 64'hC0300FFFFFFFFFFD; + y = 64'h3FB03FFFFFFF7FFE; + z = 64'hFFD0001FFFFFFF7E; + ans = 64'hFFD0001FFFFFFF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1123619\n"); + end + x = 64'h40EFFFEFFFFFFDFF; + y = 64'h3CA0000000000001; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FE000000000FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1124233\n"); + end + x = 64'h3FE0000000000000; + y = 64'h415FFFF004000000; + z = 64'h41FEFFFFFFFFEFFF; + ans = 64'h41FF03FFFE006FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1124847\n"); + end + x = 64'h6AFFFFFFFFFDDFFF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3FCFFFC01FFFFFFF; + ans = 64'h67BFFFFFFFFDDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1125461\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC06000000000006F; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1126075\n"); + end + x = 64'hBF4F800000000006; + y = 64'hBF800003FFBFFFFF; + z = 64'h550E46264996A342; + ans = 64'h550E46264996A342; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1126689\n"); + end + x = 64'h3FE0000000000000; + y = 64'h3FD0000000000001; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h3FC0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1127303\n"); + end + x = 64'hBCAFFF7FBFFFFFFF; + y = 64'hBF8FFFFFFFFFE7FF; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1127917\n"); + end + x = 64'h3FE0000000000000; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3CAEFFFFF7FFFFFF; + ans = 64'h3FD0000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1128531\n"); + end + x = 64'hC0F2269EA37979B7; + y = 64'hC3E5044465ED15FE; + z = 64'h99006FFFFFFFFFFE; + ans = 64'h44E7D78775FB434B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1129145\n"); + end + x = 64'hBDAFFFFFBFFFFFC0; + y = 64'h3FE0000000000000; + z = 64'h3FD0000000000000; + ans = 64'h3FCFFFFFFFFC0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1129759\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC02FBFFFFFFFFC00; + z = 64'hBF4FFFFFFC080000; + ans = 64'hC01FC0FFFFFFDC40; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1130373\n"); + end + x = 64'h43C4B497E002A189; + y = 64'h3FE0000000000001; + z = 64'h3FB00000013FFFFF; + ans = 64'h43B4B497E002A18A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1130987\n"); + end + x = 64'h3FE0000000000000; + y = 64'hBA8FDFFFFFFFF7FF; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1131601\n"); + end + x = 64'hC05007F800000000; + y = 64'h7FD0010000000007; + z = 64'h3DCE087CDC3EE03D; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1132215\n"); + end + x = 64'h3FE0000000000000; + y = 64'h3FF0000000000000; + z = 64'h0000000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1132829\n"); + end + x = 64'h40100000000040FF; + y = 64'h40382A63E3DB7F32; + z = 64'hC000000000000001; + ans = 64'h4057AA63E3DBE15D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1133443\n"); + end + x = 64'h3FE0000000000000; + y = 64'h3FF0000000000001; + z = 64'h403BFF7FFFFFFFFE; + ans = 64'h403C7F7FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1134057\n"); + end + x = 64'hCCEFFFFFDFF7FFFF; + y = 64'h1B3C000000003FFE; + z = 64'hC3E000007FFBFFFE; + ans = 64'hC3E000007FFBFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1134671\n"); + end + x = 64'h4420003FFFFF8000; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h3CA0000000000001; + ans = 64'h4430003FFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1135285\n"); + end + x = 64'h3FE0000000000000; + y = 64'h380FFFFFFD7FFFFE; + z = 64'hBFEFBFFFFFFFFFF0; + ans = 64'hBFEFBFFFFFFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1135899\n"); + end + x = 64'h41EC9BDA337E16AB; + y = 64'h4000000000000000; + z = 64'hB50FFFFFFFFEFFEE; + ans = 64'h41FC9BDA337E16AB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1136513\n"); + end + x = 64'h3FE0000000000000; + y = 64'hA6741A0E20872621; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1137127\n"); + end + x = 64'h5FA00000010000FF; + y = 64'hC000000003FFFDFE; + z = 64'h3CC7741A54494340; + ans = 64'hDFB0000004FFFEFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1137741\n"); + end + x = 64'h3FE0000000000000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1138355\n"); + end + x = 64'hBFE7198953B924E4; + y = 64'h19E201FFFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1138969\n"); + end + x = 64'h3FE0000000000000; + y = 64'h4010000000000000; + z = 64'h3FDFBFFFFFFEFFFF; + ans = 64'h4003F7FFFFFFE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1139583\n"); + end + x = 64'h7FE00000003FFFEE; + y = 64'hC6A01000000007FE; + z = 64'h386001000FFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1140197\n"); + end + x = 64'h41CC0C7A32611D71; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h41FC0C7A32611D70; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1140811\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC1FFFFFF000001FF; + z = 64'h800FFFFFFFFFFDDE; + ans = 64'hC1EFFFFF000001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1141425\n"); + end + x = 64'h402FFFFFFF7F7FFE; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h801FFFEFFFFFFE00; + ans = 64'h405FFFFFFF7F7FFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1142039\n"); + end + x = 64'h3FE0000000000000; + y = 64'hE0600007FFFFFC00; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'hE0500007FFFFFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1142653\n"); + end + x = 64'h42CBB2BFC8A9AB72; + y = 64'hFFEFFFFFF800001E; + z = 64'hC3D1FFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1143267\n"); + end + x = 64'h3FE0000000000000; + y = 64'h4340000000000001; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1143881\n"); + end + x = 64'h800A63B087D63021; + y = 64'h42DFFFFFFDFFFC00; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1144495\n"); + end + x = 64'h3FE0000000000000; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h4A2FFFFFFFDFFFFF; + ans = 64'h4A2FFFFFFFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1145109\n"); + end + x = 64'h42EA28F2F54C20DD; + y = 64'hBFDFFFEFF0000000; + z = 64'h3F6FFFFFFE1FFFFF; + ans = 64'hC2DA28E5D3BE2CBC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1145723\n"); + end + x = 64'h401FFFFBFFFFFF7F; + y = 64'h7FE0000000000001; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1146337\n"); + end + x = 64'h3FE0000000000000; + y = 64'h40FAA9DBBA56F555; + z = 64'h45100000400003FF; + ans = 64'h45100000400003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1146951\n"); + end + x = 64'h3A3FFF8000007FFF; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h400FFBFFFFFFFFBF; + ans = 64'h7A3FFF8000007FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1147565\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC7E0004003FFFFFE; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'hC7D0004003FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1148179\n"); + end + x = 64'h43F027459B92631B; + y = 64'hC060000200000003; + z = 64'h43E0000012000000; + ans = 64'hC4601747A0691690; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1148793\n"); + end + x = 64'h3FE0000000000000; + y = 64'h7FF0000000000000; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1149407\n"); + end + x = 64'hC1DFE00000000001; + y = 64'h37FFFFFFFBFFBFFE; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1150021\n"); + end + x = 64'h3FE0000000000000; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h37EFFC00007FFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1150635\n"); + end + x = 64'h418FC8D90993BDBB; + y = 64'h46AFFFDFFFFEFFFF; + z = 64'h404B2AA5588E3698; + ans = 64'h484FC8B940B9B5DF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1151249\n"); + end + x = 64'h3F35B1AD19CCBB88; + y = 64'h8000000000000000; + z = 64'h0000000000000000; + ans = 64'h0000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1151863\n"); + end + x = 64'h3FE0000000000000; + y = 64'h41CFFFFEFFFFC000; + z = 64'hC7E00000008FFFFF; + ans = 64'hC7E00000008FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1152477\n"); + end + x = 64'h3FCFF0000000007F; + y = 64'h8000000000000001; + z = 64'h4024D806BCE3C412; + ans = 64'h4024D806BCE3C412; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1153091\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC310000043FFFFFE; + z = 64'h4010000000000000; + ans = 64'hC300000043FFFFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1153705\n"); + end + x = 64'h22973342C2D94245; + y = 64'hBC5000007FFFFF00; + z = 64'h3FD000FFFFFFFF7E; + ans = 64'h3FD000FFFFFFFF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1154319\n"); + end + x = 64'h3FE0000000000000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1154933\n"); + end + x = 64'hBFB60F9E9B37FF4D; + y = 64'hBE9007FFFFFFFBFF; + z = 64'hBFD0000000000001; + ans = 64'hBFCFFFFFD3CAB32D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1155547\n"); + end + x = 64'h3FE0000000000000; + y = 64'h8010000000000001; + z = 64'h7FF0000000000023; + ans = 64'h7FF8000000000023; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1156161\n"); + end + x = 64'hBF600000000001FF; + y = 64'h401E1107EFF9A8DC; + z = 64'hCFC0FE0000000000; + ans = 64'hCFC0FE0000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1156775\n"); + end + x = 64'hC383A01B0A54CF13; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1157389\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC3E89E6D0A424544; + z = 64'h000053D77B90F71D; + ans = 64'hC3D89E6D0A424544; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1158003\n"); + end + x = 64'hC1FFFFFFDF800000; + y = 64'hBCA0000000000000; + z = 64'hBDF0200000003FFE; + ans = 64'h3EAFFDFBDF7FFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1158617\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC3C0000001DFFFFF; + z = 64'h4000000000000001; + ans = 64'hC3B0000001DFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1159231\n"); + end + x = 64'hC34FFFFFFFFF87FE; + y = 64'h41EFFFFFFFF003FF; + z = 64'h105000004000000F; + ans = 64'hC54FFFFFFFEF8BFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1159845\n"); + end + x = 64'h3FE0000000000000; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1160459\n"); + end + x = 64'hC3E00000005FFFFF; + y = 64'h8C5001FFFFFFBFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1161073\n"); + end + x = 64'h3FE0000000000000; + y = 64'hBFD0000000000000; + z = 64'hC7FFFFFBFDFFFFFF; + ans = 64'hC7FFFFFBFDFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1161687\n"); + end + x = 64'h490723EB06262E31; + y = 64'hFD18000000FFFFFF; + z = 64'h3C1000004000FFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1162301\n"); + end + x = 64'hB7EFFFFFFBFFF800; + y = 64'hBFD0000000000001; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1162915\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC7F02007FFFFFFFE; + z = 64'hBB5605238E05DFBA; + ans = 64'hC7E02007FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1163529\n"); + end + x = 64'h7FFFFFFFF7FFFFFA; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h318E000004000000; + ans = 64'h7FFFFFFFF7FFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1164143\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC0353E5BC7EF131D; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'hC0213E5BC7EF131D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1164757\n"); + end + x = 64'hC3400040000003FE; + y = 64'hC03FE00000100000; + z = 64'h3FF494F28DCAC0D3; + ans = 64'h438FE07F80100834; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1165371\n"); + end + x = 64'h3FE0000000000000; + y = 64'hBFE0000000000001; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC011000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1165985\n"); + end + x = 64'hC3EFFFFFFFE003FF; + y = 64'hC21FBFFFFFDFFFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h461FBFFFFFC043F5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1166599\n"); + end + x = 64'h3FE0000000000000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h434FFFFF1FFFFFFF; + ans = 64'h434FFFFF1FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1167213\n"); + end + x = 64'h3E10000207FFFFFF; + y = 64'hC5C185538585F023; + z = 64'h7FD0000FFFFFBFFF; + ans = 64'h7FD0000FFFFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1167827\n"); + end + x = 64'h800FFFFFFDFFFFFF; + y = 64'hBFF0000000000000; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1168441\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC1CFFFFFFFF7FFDF; + z = 64'hC01000000003FFFB; + ans = 64'hC1C0000001FBFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1169055\n"); + end + x = 64'h9D9000000000407F; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3FC000800000FFFF; + ans = 64'h3FC000800000FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1169669\n"); + end + x = 64'h3FE0000000000000; + y = 64'h4163FFFFFFFFFFBE; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h415400003FFFFFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1170283\n"); + end + x = 64'hC03FFFFFFFFF7EFE; + y = 64'h381EFFFFFFFFFF7E; + z = 64'h3FE800001FFFFFFF; + ans = 64'h3FE800001FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1170897\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC000000000000000; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hC007FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1171511\n"); + end + x = 64'h3FFB431B34B7CE0C; + y = 64'hC7F000000003FFFC; + z = 64'h8010000000000000; + ans = 64'hC7FB431B34BE9ECC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1172125\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC1F25D65F88033E0; + ans = 64'hC1F25D65F8A033E0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1172739\n"); + end + x = 64'h800FEEFFFFFFFFFF; + y = 64'h7FD1FFFFFFFFFFF6; + z = 64'hBF70000000003FBE; + ans = 64'hBFF1FCE000000035; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1173353\n"); + end + x = 64'h09C0200002000000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1173967\n"); + end + x = 64'h3FE0000000000000; + y = 64'h4010000000801FFF; + z = 64'hBFAFFFC800000000; + ans = 64'h3FFF0001C1003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1174581\n"); + end + x = 64'hC1C581FBC774F374; + y = 64'hC010000000000001; + z = 64'hC00FFFF3FFFFFFFE; + ans = 64'h41E581FBC6F4F3A5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1175195\n"); + end + x = 64'h3FE0000000000000; + y = 64'h3BFFFFFFFFFFF6FF; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1175809\n"); + end + x = 64'h37FBD52CF116FCB7; + y = 64'h3FC8800000000000; + z = 64'h43F0FFFFFFFFFFFE; + ans = 64'h43F0FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1176423\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBFF0000000000000; + ans = 64'hC013FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1177037\n"); + end + x = 64'h400FFFFFEFFFFFFB; + y = 64'hAAF0C734E2A389B1; + z = 64'h8000000000000001; + ans = 64'hAB10C734DA3FEF3D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1177651\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC340000000000001; + z = 64'h5C37AF0E6B6739FF; + ans = 64'h5C37AF0E6B6739FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1178265\n"); + end + x = 64'hB7EFFFF80000000F; + y = 64'hDD90000020000007; + z = 64'hB80B36A0270E1A29; + ans = 64'h558FFFF83FFFF01D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1178879\n"); + end + x = 64'hBE97FFFFFFFFFFFC; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC010000000000001; + ans = 64'h41F7FFFFFFBFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1179493\n"); + end + x = 64'h3FE0000000000000; + y = 64'h4800001FFFFFFFFE; + z = 64'h72E0000010000000; + ans = 64'h72E0000010000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1180107\n"); + end + x = 64'hC05000403FFFFFFF; + y = 64'hFFE0000000000000; + z = 64'h397EBF9F5C9C83E9; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1180721\n"); + end + x = 64'h3FE0000000000000; + y = 64'h0B9CBD5808FDB0FE; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1181335\n"); + end + x = 64'hBFF9104A39BDD7BB; + y = 64'h3FFEFFFFEFFFFFFF; + z = 64'h4020000FFFFFFFF0; + ans = 64'h4013DC3C124C1DF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1181949\n"); + end + x = 64'h3FE0000000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hBFE0000000000001; + ans = 64'hFFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1182563\n"); + end + x = 64'hC1901FFBFFFFFFFE; + y = 64'h3CF010001FFFFFFF; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1183177\n"); + end + x = 64'h3FE0000000000000; + y = 64'hFFF0000000000000; + z = 64'hBFCCA72E89F506ED; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1183791\n"); + end + x = 64'h000020000000001E; + y = 64'hD9AFFFFFFFEFFFDE; + z = 64'h3FB1000000008000; + ans = 64'h3FB1000000008000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1184405\n"); + end + x = 64'h41F89968EBD9BC5C; + y = 64'hFFF0000000000001; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1185019\n"); + end + x = 64'h3FE0000000000000; + y = 64'h43D1CCF3DD115F1B; + z = 64'h4000100003FFFFFF; + ans = 64'h43C1CCF3DD115F1B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1185633\n"); + end + x = 64'h801DFFFFFFFF7FFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h002E0001FFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1186247\n"); end x = 64'h3FE0000000000001; - y = 64'h001FFFFFFFFFFFFF; + y = 64'hB81FFFFFF7FE0000; z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; @@ -27814,12 +90888,482 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1190273\n"); + $fwrite(fp,"1186861\n"); end - x = 64'hC1DFFFF000000FFF; + x = 64'hBFD0000000000100; + y = 64'h43400000000007FE; + z = 64'hBF80200007FFFFFF; + ans = 64'hC3200000000008FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1187475\n"); + end + x = 64'h3FE0000000000001; + y = 64'h0000000000000001; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1188089\n"); + end + x = 64'hC1E7433321AAB73A; + y = 64'hC20007FFFFFFFFE0; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1188703\n"); + end + x = 64'h3FE0000000000001; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3CAFF0000000003F; + ans = 64'h3CAFF0000000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1189317\n"); + end + x = 64'h43D00004000003FE; + y = 64'h8D00800000000000; + z = 64'h775FFFFFF7FFFF7F; + ans = 64'h775FFFFFF7FFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1189931\n"); + end + x = 64'h400FFFFFFFFC0001; + y = 64'h0010000000000000; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1190545\n"); + end + x = 64'h3FE0000000000001; + y = 64'h528FFFDFF7FFFFFF; + z = 64'h41C0020080000000; + ans = 64'h527FFFDFF8000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1191159\n"); + end + x = 64'hD3CFEFFFBFFFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hDC7000000000401F; + ans = 64'hDC7000000000401F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1191773\n"); + end + x = 64'h3FE0000000000001; + y = 64'h2A9C69744FCB1FC1; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h2A8C69744FCB1FC3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1192387\n"); + end + x = 64'hC15000000000011F; + y = 64'hC01FF7FFFFFFDFFF; + z = 64'hC67FFFFFFFFFFFC8; + ans = 64'hC67FFFFFFFFFFFC8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1193001\n"); + end + x = 64'h3FE0000000000001; y = 64'h3CA0000000000000; - z = 64'hC3DA1DEAED50332B; - ans = 64'hC3DA1DEAED50332B; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCA7FFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -27861,12 +91405,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1192287\n"); + $fwrite(fp,"1193615\n"); end - x = 64'hFC50FF7FFFFFFFFF; - y = 64'hB8FFC003FFFFFFFF; - z = 64'h41CFFFFFFFFE03FE; - ans = 64'h7560DD831FEFFFFE; + x = 64'hBFDAFBBC119D048E; + y = 64'h41DFFFFC00200000; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; rn = 1; rz = 0; rm = 0; @@ -27908,12 +91452,200 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1194301\n"); + $fwrite(fp,"1194229\n"); end x = 64'h3FE0000000000001; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC1C0000008000010; + ans = 64'hC1C0000008000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1194843\n"); + end + x = 64'h3F3FFFFFFFC00001; + y = 64'h832FFFFFFFFFF400; + z = 64'hB8100001FFFFC000; + ans = 64'hB8100001FFFFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1195457\n"); + end + x = 64'h197FFEFFFFFFEFFF; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hBFF0000000000000; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1196071\n"); + end + x = 64'h3FE0000000000001; + y = 64'h3FCF000000400000; + z = 64'h50E00000000000FE; + ans = 64'h50E00000000000FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1196685\n"); + end + x = 64'hE7BFFFFC0000007E; y = 64'h3FD0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFEC000000000001; + z = 64'hFFFE22D338585265; + ans = 64'hFFFE22D338585265; rn = 1; rz = 0; rm = 0; @@ -27955,106 +91687,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1196315\n"); - end - x = 64'hC65000000000003D; - y = 64'h3FE0000000000000; - z = 64'hC7F0008000080000; - ans = 64'hC7F0008002080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1198329\n"); - end - x = 64'hC3E00005FFFFFFFF; - y = 64'hC3AFFFFFFFFFFC08; - z = 64'h403FFFFFFFFFFFFF; - ans = 64'h47A00005FFFFFE03; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1200343\n"); + $fwrite(fp,"1197299\n"); end x = 64'h3FE0000000000001; - y = 64'h3FF0000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + y = 64'h001FFFE000001FFF; + z = 64'h0010000000000000; + ans = 64'h001FFFF000001000; rn = 1; rz = 0; rm = 0; @@ -28096,12 +91734,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1202357\n"); + $fwrite(fp,"1197913\n"); end - x = 64'hC03FFFFFFFE00000; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'h47F000001FFFBFFF; - ans = 64'h47F000001FFFBFFF; + x = 64'hBFD40000000003FF; + y = 64'hC5B1000001FFFFFF; + z = 64'h4050000000FFFDFF; + ans = 64'h459540000280043E; rn = 1; rz = 0; rm = 0; @@ -28143,59 +91781,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1204371\n"); - end - x = 64'hF35FFFFFFFFFFFC1; - y = 64'hC22FFFFFFFFFD000; - z = 64'h00220FFFFFFFFFFE; - ans = 64'h759FFFFFFFFFCFC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1206385\n"); + $fwrite(fp,"1198527\n"); end x = 64'h3FE0000000000001; - y = 64'h4010000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hBCA0000000000000; + ans = 64'h3FCFFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -28237,12 +91828,905 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1208399\n"); + $fwrite(fp,"1199141\n"); end - x = 64'hA54C000000FFFFFF; + x = 64'h410FE00000000001; + y = 64'hB800000047FFFFFF; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1199755\n"); + end + x = 64'h3FE0000000000001; + y = 64'h3FE0000000000001; + z = 64'h40780CC8FBC669E4; + ans = 64'h407810C8FBC669E4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1200369\n"); + end + x = 64'h403A681B52736AB4; + y = 64'hB547FFFFFFFFF7FF; + z = 64'hBFE0000007FFFFBF; + ans = 64'hBFE0000007FFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1200983\n"); + end + x = 64'hFFEFFFFFFFFFF800; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hBFE0000000000001; + ans = 64'hFFEFFFFFFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1201597\n"); + end + x = 64'h3FE0000000000001; + y = 64'h480FFFFFEFFFFFF7; + z = 64'hC7F0000000023FFF; + ans = 64'h47EFFFFFDFFB7FF4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1202211\n"); + end + x = 64'h802FFFFDFBFFFFFF; + y = 64'h3FF0000000000000; + z = 64'hBFFFBFFFFFFBFFFF; + ans = 64'hBFFFBFFFFFFBFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1202825\n"); + end + x = 64'h3FE0000000000001; + y = 64'h415F94D2F6C29D24; + z = 64'h0000000000000001; + ans = 64'h414F94D2F6C29D26; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1203439\n"); + end + x = 64'h3FCB3C1786B1DCDD; + y = 64'h40001000000001FF; + z = 64'hC01000000203FFFE; + ans = 64'hC00C95159040EDB8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1204053\n"); + end + x = 64'h3FE0000000000001; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h8010000000000001; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1204667\n"); + end + x = 64'hC1F1FFFFFF000000; + y = 64'h3F50040002000000; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'hC152047E013FC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1205281\n"); + end + x = 64'h3FE0000000000001; + y = 64'h4000000000000000; + z = 64'h43FFFFFFFFF01FFE; + ans = 64'h43FFFFFFFFF01FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1205895\n"); + end + x = 64'hC030000400100000; + y = 64'hC340001FFFFFFFFE; + z = 64'hFFE000003FDFFFFF; + ans = 64'hFFE000003FDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1206509\n"); + end + x = 64'hB80000000000081F; + y = 64'h4000000000000001; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1207123\n"); + end + x = 64'h3FE0000000000001; + y = 64'hB7E0000000001100; + z = 64'h3FD04000000007FF; + ans = 64'h3FD04000000007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1207737\n"); + end + x = 64'hC3F0803FFFFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h863FFFFFFEFFFFC0; + ans = 64'hC410803FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1208351\n"); + end + x = 64'h3FE0000000000001; + y = 64'h40100000041FFFFE; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1208965\n"); + end + x = 64'h3FCFAA45B9D49991; + y = 64'h306FDFFFFFFEFFFF; + z = 64'h9C3000000000FFFB; + ans = 64'h304F8A9B7419C7A4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1209579\n"); + end + x = 64'h3FE0000000000001; + y = 64'h4010000000000001; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h4000000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1210193\n"); + end + x = 64'hBEFCAD5EA5228D2B; + y = 64'hC3EFFFFFFFFFFFBC; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h42FCAD5EA5228D2E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1210807\n"); + end + x = 64'h3FE0000000000001; y = 64'h401FFFFFFFFFFFFE; - z = 64'hC0700000002007FE; - ans = 64'hC0700000002007FE; + z = 64'h47F000000040FFFF; + ans = 64'h47F000000040FFFF; rn = 1; rz = 0; rm = 0; @@ -28284,12 +92768,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1210413\n"); + $fwrite(fp,"1211421\n"); end - x = 64'hC1D000803FFFFFFE; - y = 64'h3FEFFC00000000FE; - z = 64'hBFFFFFFEFFFFEFFF; - ans = 64'hC1CFFD0060F000F2; + x = 64'h434005FFFFFFFFFE; + y = 64'h3FBFFFFFCFFFFFFF; + z = 64'h3F5FFFFFFFFFFFCF; + ans = 64'h431005FFE7F6FFFE; rn = 1; rz = 0; rm = 0; @@ -28331,433 +92815,245 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1212427\n"); + $fwrite(fp,"1212035\n"); + end + x = 64'hC01FFFFF7FFFFFEF; + y = 64'h4340000000000000; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hC36FFFFF7FFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1212649\n"); + end + x = 64'h3FE0000000000001; + y = 64'h43FFFFFC00100000; + z = 64'hC80A2913FEE53A41; + ans = 64'hC80A2913FEE53A41; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1213263\n"); + end + x = 64'h3808F00FB1D7348D; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h43D56A1EBF8784C2; + ans = 64'h43D56A1EBF8784C2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1213877\n"); + end + x = 64'h3FE0000000000001; + y = 64'h3FF00000FBFFFFFF; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1214491\n"); + end + x = 64'h53AFCC613E2DB334; + y = 64'hBFDFE00000001FFF; + z = 64'h47F4000200000000; + ans = 64'hD39FAC94DCEFA54C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1215105\n"); end x = 64'h3FE0000000000001; y = 64'h7FE0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1214441\n"); - end - x = 64'h3FF0000080000FFF; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'h049E4F343D92384B; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1216455\n"); - end - x = 64'h403FDFFFFE000000; - y = 64'hC011DA12116127A8; - z = 64'h7D8BFE3FAE41652F; - ans = 64'h7D8BFE3FAE41652F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1218469\n"); - end - x = 64'h3FE0000000000001; - y = 64'h8000000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1220483\n"); - end - x = 64'hAD80007FFFFFC000; - y = 64'h800FFFFFFFFFFFFF; - z = 64'hC48000000004000E; - ans = 64'hC48000000004000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1222497\n"); - end - x = 64'h3F1FFFFF7F000000; - y = 64'h41E007FFF0000000; - z = 64'h3FAA435B79A850E6; - ans = 64'h411007FFE3E67734; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1224511\n"); - end - x = 64'h3FE0000000000001; - y = 64'h801FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1226525\n"); - end - x = 64'h43E278F2478FCA52; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'h80149C3EC40D9749; - ans = 64'hC0A278F2478FCA51; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1228539\n"); - end - x = 64'hC310000040001FFF; - y = 64'hBFB03FFFFFFFFFFD; - z = 64'h41CFBFBFFFFFFFFE; - ans = 64'h42D0401020E0207C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1230553\n"); - end - x = 64'h3FE0000000000001; - y = 64'hBFDFFFFFFFFFFFFE; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -28801,7 +93097,1511 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1232567\n"); + $fwrite(fp,"1215719\n"); + end + x = 64'h3D4BE86A57F38F49; + y = 64'hB7E71747894EDFF3; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1216333\n"); + end + x = 64'h3FE0000000000001; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h3FEF01FFFFFFFFFE; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1216947\n"); + end + x = 64'hC2E000007FFFFFFE; + y = 64'hBFB0000800020000; + z = 64'hC7FE0000001FFFFE; + ans = 64'hC7FE0000001FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1217561\n"); + end + x = 64'h4A37FFFFBFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hBCA0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1218175\n"); + end + x = 64'h3FE0000000000001; + y = 64'h43FF1370D02201AA; + z = 64'hC013FFFFFFFFFFFC; + ans = 64'h43EF1370D02201AC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1218789\n"); + end + x = 64'hBF6D59563B67BDFB; + y = 64'h7FF0000000000001; + z = 64'h401FF8000000FFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1219403\n"); + end + x = 64'h3FE0000000000001; + y = 64'h41F000FFFFFEFFFE; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1220017\n"); + end + x = 64'hBE422263AC5FA438; + y = 64'hC0E5FEBF1FFB3F2D; + z = 64'h4806E95AD3698BE1; + ans = 64'h4806E95AD3698BE1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1220631\n"); + end + x = 64'h3FE0000000000001; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h7FF0000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1221245\n"); + end + x = 64'h37F3488C88AB3C1E; + y = 64'hC0353E87080D3A0F; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1221859\n"); + end + x = 64'h3FE0000000000001; + y = 64'h8000000000000001; + z = 64'h406987D720CD2CFD; + ans = 64'h406987D720CD2CFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1222473\n"); + end + x = 64'hFFE0000001FFFEFF; + y = 64'hC0C7FFFFFFFFFFFC; + z = 64'h480FF7FFFFFFF7FF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1223087\n"); + end + x = 64'hBFE00000000EFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h8010000000000001; + ans = 64'h8007FFFFFFF88002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1223701\n"); + end + x = 64'h3FE0000000000001; + y = 64'hC6BFFFFBFFFFFFFE; + z = 64'h40000FFFFFFFFFEE; + ans = 64'hC6AFFFFC00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1224315\n"); + end + x = 64'hBA0FFFFE000000FF; + y = 64'h8010000000000000; + z = 64'h5730000081FFFFFF; + ans = 64'h5730000081FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1224929\n"); + end + x = 64'h3FE0000000000001; + y = 64'h37E080000000000F; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1225543\n"); + end + x = 64'h7FF000000001FFDF; + y = 64'hAE2FFFF7DFFFFFFE; + z = 64'hFFDE52E8C5C19871; + ans = 64'h7FF800000001FFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1226157\n"); + end + x = 64'h3FE0000000000001; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1226771\n"); + end + x = 64'h3FB0087FFFFFFFFE; + y = 64'h401009375F1B01C4; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FF4046F11216206; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1227385\n"); + end + x = 64'h3FE0000000000001; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h402FF8001FFFFFFE; + ans = 64'h402FF8001FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1227999\n"); + end + x = 64'h43FE00007FFFFFFF; + y = 64'hC3C04000001FFFFF; + z = 64'h801000FFC0000000; + ans = 64'hC7CE7800823BFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1228613\n"); + end + x = 64'hB80C2C93CB9EB3AC; + y = 64'hBCA0000000000001; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h34BC2C93CB9EB3AE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1229227\n"); + end + x = 64'h3FE0000000000001; + y = 64'hC3FFFE000FFFFFFE; + z = 64'hB810000000000000; + ans = 64'hC3EFFE0010000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1229841\n"); + end + x = 64'h4090000000220000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hC000000800000008; + ans = 64'hC000000800000208; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1230455\n"); + end + x = 64'h3FE0000000000001; + y = 64'h47F0000020001000; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'h47E0000020001001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1231069\n"); + end + x = 64'hB8007FFFFFFFBFFF; + y = 64'hC07FFFF80000000F; + z = 64'h41E7FFFFFFFFDFFF; + ans = 64'h41E7FFFFFFFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1231683\n"); + end + x = 64'h3FE0000000000001; + y = 64'hBFD0000000000001; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1232297\n"); + end + x = 64'hC1E28F5AA84A2661; + y = 64'h408CC4DF0D0607D2; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'hC280AF9EBD1524C3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1232911\n"); + end + x = 64'h3FE0000000000001; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h4D3BE3F191496943; + ans = 64'h4D3BE3F191496943; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1233525\n"); + end + x = 64'hC1CFFFFFFFFF5FFF; + y = 64'h37F05C7808D8323D; + z = 64'h402DB1C05FC1A8CE; + ans = 64'h402DB1C05FC1A8CE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1234139\n"); + end + x = 64'hFFEFF7F7FFFFFFFE; + y = 64'hBFE0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1234753\n"); + end + x = 64'h3FE0000000000001; + y = 64'hB80000001FFFBFFE; + z = 64'h7FBDDD0E62681E3C; + ans = 64'h7FBDDD0E62681E3C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1235367\n"); end x = 64'h39260035ABDD89AD; y = 64'hBFEFFFFFFFFFFFFF; @@ -28848,12 +94648,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1234581\n"); + $fwrite(fp,"1235981\n"); end - x = 64'hC1A00000000017FF; - y = 64'hC800000200000010; - z = 64'hFC3F00000000FFFF; - ans = 64'hFC3F00000000FFFF; + x = 64'h3FE0000000000001; + y = 64'h8000004000000003; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -28897,1137 +94697,244 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"1236595\n"); end + x = 64'hC3CFFFFFFFEFFFFC; + y = 64'h3800000100000000; + z = 64'h0951CEBF00D210BB; + ans = 64'hBBE00000FFF7FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1237209\n"); + end x = 64'h3FE0000000000001; + y = 64'hBFF0000000000000; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401DFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1237823\n"); + end + x = 64'h3CA0000007FFBFFF; + y = 64'h8003FFFFFFEFFFFF; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1238437\n"); + end + x = 64'h3FE0000000000001; + y = 64'hBFF0000000000001; + z = 64'hC7E00FFFFFFFFBFE; + ans = 64'hC7E00FFFFFFFFBFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1239051\n"); + end + x = 64'hAC08231D9520F66E; + y = 64'h9D9AAF33D341D625; + z = 64'hBF3FFC0000000002; + ans = 64'hBF3FFC0000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1239665\n"); + end + x = 64'hBFD035DDA176DAD8; y = 64'hBFFFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1238609\n"); - end - x = 64'hBFE0FFEFFFFFFFFF; - y = 64'hC000000000000001; - z = 64'hC340000000002080; - ans = 64'hC34000000000207F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1240623\n"); - end - x = 64'h3FCFFFF80003FFFF; - y = 64'h41EE0000007FFFFE; - z = 64'hB8E5FCA486B3001A; - ans = 64'h41CDFFF88083BFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1242637\n"); - end - x = 64'h3FE0000000000001; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hC014000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1244651\n"); - end - x = 64'h44C4C56F2310E46D; - y = 64'hC340000000000001; - z = 64'h6DFFFFFFFFF800FF; - ans = 64'h6DFFFFFFFFF800FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1246665\n"); - end - x = 64'h390067D3F6BBE86D; - y = 64'hC7C4863B5C262EE4; - z = 64'h7FEF7FFFFFFFEFFE; - ans = 64'h7FEF7FFFFFFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1248679\n"); - end - x = 64'h3FE0000000000001; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1250693\n"); - end - x = 64'h06C0000003FFFDFF; - y = 64'hFFF0000000000000; - z = 64'h3811FFFFFFFFFFEF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1252707\n"); - end - x = 64'hFFD000407FFFFFFF; - y = 64'h8020FFFFFFFE0000; - z = 64'h404136D99D2D1461; - ans = 64'h404246DDE5ACF460; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1254721\n"); - end - x = 64'h3FEFFFFFFFFFFFFF; - y = 64'h0000000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1256735\n"); - end - x = 64'hBB41FFFFFFF00000; - y = 64'h0010000000000000; - z = 64'h801F144F5AF77117; - ans = 64'h801F144F5AF77117; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1258749\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'h4531FFFFFFF7FFFE; - z = 64'h3FE001FFFFFFFFFB; - ans = 64'hC551FFFFFFF7FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1260763\n"); - end - x = 64'h3FEFFFFFFFFFFFFF; - y = 64'h3CA0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBC9FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1262777\n"); - end - x = 64'hB7E0000080000800; - y = 64'h3FD0000000000000; - z = 64'h00A40000001FFFFF; - ans = 64'hB7C0000080000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1264791\n"); - end - x = 64'hBFD0100007FFFFFF; - y = 64'h3FD297EE8E336CA8; - z = 64'hC01000000000083E; - ans = 64'hC0104AAA1A183E9B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1266805\n"); - end - x = 64'h3FEFFFFFFFFFFFFF; - y = 64'h3FE0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1268819\n"); - end - x = 64'h3CA040000000003F; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h47E98A1D9E231C6C; - ans = 64'h47E98A1D9E231C6C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1270833\n"); - end - x = 64'hFFDCD4A9AF8FB7F0; - y = 64'hBFA57144A8767CCA; - z = 64'h3C8FF000FFFFFFFF; - ans = 64'h7F93519C2E1A14C2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1272847\n"); - end - x = 64'h3FEFFFFFFFFFFFFF; - y = 64'h4000000000000000; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1274861\n"); - end - x = 64'hC03FFF0000002000; - y = 64'h400FFFFFFFFFFFFE; - z = 64'hB7E0DB97C33BBBF0; - ans = 64'hC05FFF0000001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1276875\n"); - end - x = 64'h464FF83FFFFFFFFF; - y = 64'h3FF0007FFFFFFFFF; - z = 64'h3FB1000000001FFF; - ans = 64'h464FF93FC1FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1278889\n"); - end - x = 64'h3FEFFFFFFFFFFFFF; - y = 64'h4340000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1280903\n"); - end - x = 64'hBFF000000000001D; - y = 64'h434FFFFFFFFFFFFE; - z = 64'h7FED8C5A62D13B80; - ans = 64'h7FED8C5A62D13B80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1282917\n"); - end - x = 64'hFFD0000040000400; - y = 64'h002D129AC2DAF941; - z = 64'h6DA0800000000001; - ans = 64'h6DA0800000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1284931\n"); - end - x = 64'h3FEFFFFFFFFFFFFF; - y = 64'h7FF0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; + z = 64'h7FF0000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -30070,12 +94977,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1286945\n"); + $fwrite(fp,"1240279\n"); end - x = 64'h41DFFFFFFFFFFFDA; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hC34D972CB1581033; - ans = 64'h7FFFFFFFFFFFFFFF; + x = 64'h3FE0000000000001; + y = 64'hC7F0000102000000; + z = 64'hA7202000000007FF; + ans = 64'hC7E0000102000001; rn = 1; rz = 0; rm = 0; @@ -30117,12 +95024,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1288959\n"); + $fwrite(fp,"1240893\n"); end - x = 64'h43E444929DC71DB3; - y = 64'h3FD0000080FFFFFF; - z = 64'h3E5FFFFF00000000; - ans = 64'h43C44493412FFBCA; + x = 64'h46218D1FD3FECF00; + y = 64'hC000000000000001; + z = 64'hB8100000000006FF; + ans = 64'hC6318D1FD3FECF01; rn = 1; rz = 0; rm = 0; @@ -30164,12 +95071,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1290973\n"); + $fwrite(fp,"1241507\n"); end - x = 64'h3FEFFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; + x = 64'h3FE0000000000001; + y = 64'h381FFFF000000FFF; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; rn = 1; rz = 0; rm = 0; @@ -30211,12 +95118,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1292987\n"); + $fwrite(fp,"1242121\n"); end - x = 64'hC1D3B0AE9C0EB661; - y = 64'h801FFFFFFFFFFFFF; - z = 64'hFF9BFFFFFFFFC000; - ans = 64'hFF9BFFFFFFFFC000; + x = 64'h471FFFC000000FFE; + y = 64'h37EFFF9FFFFFFFFE; + z = 64'h002FFFFC0000003F; + ans = 64'h3F1FFF6000C00FFC; rn = 1; rz = 0; rm = 0; @@ -30258,12 +95165,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1295001\n"); + $fwrite(fp,"1242735\n"); end - x = 64'h42AEFFFFFFFFFBFE; - y = 64'h4040080000040000; - z = 64'hC0000000000087FE; - ans = 64'h42FF0F800007BBDC; + x = 64'h3FE0000000000001; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h4010000000000000; + ans = 64'h4000000000000000; rn = 1; rz = 0; rm = 0; @@ -30305,12 +95212,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1297015\n"); + $fwrite(fp,"1243349\n"); end - x = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + x = 64'h41FB90A7E035BEF8; + y = 64'hB7EFFFFFFFF80200; + z = 64'h3CA0000000000001; + ans = 64'h3C9FFFFFFFFFF91E; rn = 1; rz = 0; rm = 0; @@ -30352,12 +95259,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1299029\n"); + $fwrite(fp,"1243963\n"); end - x = 64'h4030080004000000; - y = 64'hBFD0000000000001; - z = 64'h74A074EB9DE02CCE; - ans = 64'h74A074EB9DE02CCE; + x = 64'h3FE0000000000001; + y = 64'hC010000000000000; + z = 64'hC3E51EE0A2AE97C7; + ans = 64'hC3E51EE0A2AE97C7; rn = 1; rz = 0; rm = 0; @@ -30399,12 +95306,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1301043\n"); + $fwrite(fp,"1244577\n"); end - x = 64'h42401FFFFFFFFBFF; - y = 64'hBFEFFFFFFFFFC03F; - z = 64'hBE500200000003FE; - ans = 64'hC2401FFFFFFFDBDF; + x = 64'h3FDFFFFFBEFFFFFE; + y = 64'hF7D08BB81A011F46; + z = 64'hC3DF80000003FFFF; + ans = 64'hF7C08BB7F8655150; rn = 1; rz = 0; rm = 0; @@ -30446,12 +95353,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1303057\n"); + $fwrite(fp,"1245191\n"); end - x = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + x = 64'h49AA8FD4E56A0F22; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; rn = 1; rz = 0; rm = 0; @@ -30493,12 +95400,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1305071\n"); + $fwrite(fp,"1245805\n"); end - x = 64'h47FFFFFFDFEFFFFF; - y = 64'hBFF0000000000001; - z = 64'hC1EFF7FFFFFFFFFD; - ans = 64'hC7FFFFFFDFF00001; + x = 64'h3FE0000000000001; + y = 64'hC5FFFFFFFFFFBFFB; + z = 64'h801FFFFFFF7FFFDF; + ans = 64'hC5EFFFFFFFFFBFFD; rn = 1; rz = 0; rm = 0; @@ -30540,11 +95447,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1307085\n"); + $fwrite(fp,"1246419\n"); end - x = 64'hFFDB5F9FBB1A65C5; - y = 64'h4BBFDFFFFFFFFFFF; - z = 64'hBE800000000003FF; + x = 64'h7FE007FFFFFFBFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hFFE0000003FFE000; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -30587,12 +95494,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1309099\n"); + $fwrite(fp,"1247033\n"); end - x = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; + x = 64'h3FE0000000000001; + y = 64'hC3F4000400000000; + z = 64'hBFF0000000000001; + ans = 64'hC3E4000400000001; rn = 1; rz = 0; rm = 0; @@ -30634,12 +95541,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1311113\n"); + $fwrite(fp,"1247647\n"); end - x = 64'hABBFFFF7FFFFFF7E; - y = 64'hC010000000000001; - z = 64'hFFE5AD5572946888; - ans = 64'hFFE5AD5572946888; + x = 64'hC05FFFFFFFFFFEFB; + y = 64'h402FFFFEF8000000; + z = 64'hC1D1000001000000; + ans = 64'hC1D1000200FFEF80; rn = 1; rz = 0; rm = 0; @@ -30681,59 +95588,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1313127\n"); + $fwrite(fp,"1248261\n"); end - x = 64'hC2200000000100FE; - y = 64'hC1CE000000007FFE; - z = 64'h4C20020000000008; - ans = 64'h4C20020000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1315141\n"); - end - x = 64'h3FEFFFFFFFFFFFFF; + x = 64'h3FE0000000000001; y = 64'hC34FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'hC34FFFFFFFFFFFFE; + z = 64'h4000000000000001; + ans = 64'hC33FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -30775,12 +95635,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1317155\n"); + $fwrite(fp,"1248875\n"); end - x = 64'hBD7FFFFFC0000100; - y = 64'hFFE0000000000000; - z = 64'hBF1EBA24E2EE0662; - ans = 64'h7D6FFFFFC0000100; + x = 64'hC330000000107FFE; + y = 64'h4340200000040000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hC68020000014A0FE; rn = 1; rz = 0; rm = 0; @@ -30822,12 +95682,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1319169\n"); + $fwrite(fp,"1249489\n"); end - x = 64'h551DF7FFFFFFFFFF; - y = 64'hBAC0000100800000; - z = 64'hC03FDFFFFFFFBFFE; - ans = 64'hCFEDF801E06FBFFF; + x = 64'h3FE0000000000001; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h43F1000004000000; + ans = 64'h43F0FE0004000000; rn = 1; rz = 0; rm = 0; @@ -30869,11 +95729,293 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1321183\n"); + $fwrite(fp,"1250103\n"); end - x = 64'h3FEFFFFFFFFFFFFF; + x = 64'h402B03E8F7B08906; + y = 64'h412996BE0A0ABEA4; + z = 64'hC35FFFFFFCFFFFFF; + ans = 64'hC35FFFFFFCD4CB5D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1250717\n"); + end + x = 64'h405FFFFFFFFFF007; + y = 64'hFFE0000000000001; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1251331\n"); + end + x = 64'h3FE0000000000001; + y = 64'hDF9FFFFFFFFFDFEF; + z = 64'hC03FFFFFFFFFE007; + ans = 64'hDF8FFFFFFFFFDFF1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1251945\n"); + end + x = 64'hC1C54ECCB8C1D414; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hC3DFF7FFFFFFFDFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1252559\n"); + end + x = 64'h3FE0000000000001; + y = 64'hC00BFDFFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hC005FF0000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1253173\n"); + end + x = 64'hBFB2BDD6B4EE5235; + y = 64'h402FFFC00000001E; + z = 64'hBF91FDFFFFFFFFFE; + ans = 64'hBFF305A93940E86A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1253787\n"); + end + x = 64'h3FE0000000000001; y = 64'hFFF0000000000001; - z = 64'hC340000000000000; + z = 64'h3FFFFFFFFFFFFFFF; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -30916,12 +96058,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1323197\n"); + $fwrite(fp,"1254401\n"); end - x = 64'hBFBFFCFFFFFFFFFF; + x = 64'h347AFEC51BB8EC9A; + y = 64'h43D20E68A685DF5B; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h385E76ED3C9E9BCD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1255015\n"); + end + x = 64'h3FE0000000000001; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hA41003FF80000000; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1255629\n"); + end + x = 64'h0011000800000000; + y = 64'h4017797633517F39; + z = 64'hBF5F0000000003FF; + ans = 64'hBF5F0000000003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1256243\n"); + end + x = 64'h408FF7FFFF7FFFFF; y = 64'h0000000000000000; - z = 64'hC03FF80000080000; - ans = 64'hC03FF80000080000; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -30963,12 +96246,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1325211\n"); + $fwrite(fp,"1256857\n"); end - x = 64'h41C69C7D72FE8076; - y = 64'hB800001F7FFFFFFF; - z = 64'hBE37136C430968EF; - ans = 64'hBE37136C430968EF; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h4030800000FFFFFF; + z = 64'h44200FFFFFFFFF7F; + ans = 64'h44200FFFFFFFFF7F; rn = 1; rz = 0; rm = 0; @@ -31010,12 +96293,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1327225\n"); + $fwrite(fp,"1257471\n"); end - x = 64'h3FEFFFFFFFFFFFFE; + x = 64'hB7EC1C59B4C2E8E1; + y = 64'h0000000000000001; + z = 64'h00100000007FFE00; + ans = 64'h00100000007FFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1258085\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBE1FFFFFFFC0007E; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFE0000000FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1258699\n"); + end + x = 64'h403000000001FFFB; + y = 64'hBFD340F99E89EBF4; + z = 64'hCDCBCAB1F16B5FD2; + ans = 64'hCDCBCAB1F16B5FD2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1259313\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h0010000000000000; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1259927\n"); + end + x = 64'hBFBFFFFFC3FFFFFE; + y = 64'hBFB00800000FFFFE; + z = 64'h0000000000000000; + ans = 64'h3F8007FFE200FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1260541\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; y = 64'h0010000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC34080FFFFFFFFFF; + ans = 64'hC34080FFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -31057,12 +96575,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1329239\n"); + $fwrite(fp,"1261155\n"); end - x = 64'h38100000008001FF; + x = 64'hD03FF10000000000; + y = 64'h7FEA066340366A48; + z = 64'h3FBFFFFFFFF0000E; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1261769\n"); + end + x = 64'h9C9FFF8000000100; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1262383\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC030000000101FFF; + z = 64'h4020400000010000; + ans = 64'hC01F8000003E7FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1262997\n"); + end + x = 64'hC1F00007FFFFFFC0; y = 64'h3CA0000000000000; - z = 64'h801FE000003FFFFF; - ans = 64'h34C00000008001FF; + z = 64'h3DD003FFFFFDFFFE; + ans = 64'hBE9FFF0FBFFFFFA0; rn = 1; rz = 0; rm = 0; @@ -31104,12 +96763,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1331253\n"); + $fwrite(fp,"1263611\n"); end - x = 64'hC03000000103FFFF; - y = 64'h43CFFFFFFBF00000; - z = 64'hC00FFFC000000010; - ans = 64'hC40FFFFFFDF7FFFE; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hCEFFFFC00007FFFF; + z = 64'hBFD0000000000000; + ans = 64'hCEFFFFC00007FFFE; rn = 1; rz = 0; rm = 0; @@ -31151,12 +96810,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1333267\n"); + $fwrite(fp,"1264225\n"); end - x = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3FD0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3FD0000000000004; + x = 64'h205E03FFFFFFFFFF; + y = 64'h7FDB0898E3B7A8A5; + z = 64'h402750419179B0FB; + ans = 64'h60495B706898A50F; rn = 1; rz = 0; rm = 0; @@ -31198,12 +96857,294 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1335281\n"); + $fwrite(fp,"1264839\n"); end - x = 64'hBFE00FDFFFFFFFFF; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1265453\n"); + end + x = 64'hC000689C3D2EB143; + y = 64'h3C69E300BC404381; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1266067\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h3FD0000000000000; + z = 64'h40740CF10515C336; + ans = 64'h407410F10515C336; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1266681\n"); + end + x = 64'hC1C0FFFFFFFFFFC0; + y = 64'h43E00FFFFFFFFFF8; + z = 64'hBFFFFFFFE0000007; + ans = 64'hC5B110FFFFFFFFB7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1267295\n"); + end + x = 64'hC280000FFDFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h4000000000000001; + ans = 64'hC270000FFDFFDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1267909\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h5D78B059EC0D3BA4; + z = 64'h7FD0000000009FFE; + ans = 64'h7FD0000000009FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1268523\n"); + end + x = 64'hC3E1495E8BBE1289; y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h3BCFFFFC0000000E; - ans = 64'hBFD00FDFFFFFFFFE; + z = 64'h4FB000047FFFFFFE; + ans = 64'h4FB000047FFFFFFE; rn = 1; rz = 0; rm = 0; @@ -31245,12 +97186,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1337295\n"); + $fwrite(fp,"1269137\n"); end - x = 64'h439FFFFFFF0001FF; - y = 64'hC04FFFFFEF7FFFFF; - z = 64'hC1D0000000300000; - ans = 64'hC3FFFFFFEE8401FF; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h480000000005FFFF; + z = 64'hBCA0000000000001; + ans = 64'h480000000005FFFE; rn = 1; rz = 0; rm = 0; @@ -31292,12 +97233,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1339309\n"); + $fwrite(fp,"1269751\n"); end - x = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3FF0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBCC0000000000000; + x = 64'hB7EFFFFFFC000200; + y = 64'h705041FFFFFFFFFF; + z = 64'h3F23B0A5836E544A; + ans = 64'hE85041FFFDF7C103; rn = 1; rz = 0; rm = 0; @@ -31339,12 +97280,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1341323\n"); + $fwrite(fp,"1270365\n"); end - x = 64'h7FDFFFBFFFFFF7FF; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hBBDFFFFFF8000007; - ans = 64'h7FEFFFBFFFFFF7FD; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3FD0000000000001; + ans = 64'h3FF3FFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -31386,12 +97327,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1343337\n"); + $fwrite(fp,"1270979\n"); end - x = 64'hC1C985AAEB8A0850; - y = 64'h43C80000000007FF; - z = 64'hD7A0000001FFFFDF; - ans = 64'hD7A0000001FFFFDF; + x = 64'h4284920C713155BB; + y = 64'h4002F779DFFEC571; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -31433,12 +97374,529 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1345351\n"); + $fwrite(fp,"1271593\n"); end - x = 64'h3FEFFFFFFFFFFFFE; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hC6522AF710929EDB; + ans = 64'hC6522AF710929EDB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1272207\n"); + end + x = 64'hC077FFFFFFFFFFF7; + y = 64'h3FFE0000000FFFFE; + z = 64'hC1EFFFFFFFFF0001; + ans = 64'hC1F000002CFF8001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1272821\n"); + end + x = 64'hFFDFFFFFFFF8003F; + y = 64'h3FF0000000000001; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'hFFDFFFFFFFF80041; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1273435\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBC0FFFC0FFFFFFFF; + z = 64'h4004000000000001; + ans = 64'h4004000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1274049\n"); + end + x = 64'h8A9FFFFEBFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h37EFFC0000000800; + ans = 64'h37EFFC0000000800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1274663\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h43C800000FFFFFFE; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h43C800000FFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1275277\n"); + end + x = 64'hBFEFFFFFFFFFFE07; + y = 64'h401658E0BF3B7A12; + z = 64'hBD5000004003FFFE; + ans = 64'hC01658E0BF3B79B1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1275891\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h4000000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1276505\n"); + end + x = 64'hBF9DFE4AA0DF2EF9; + y = 64'h3FB01000000001FF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1277119\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hBFF00020001FFFFF; + ans = 64'h4007FFEFFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1277733\n"); + end + x = 64'hBEFFFFFB7FFFFFFF; + y = 64'h3FF2A08A53EA01BD; + z = 64'hDB700007FFFFFDFE; + ans = 64'hDB700007FFFFFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1278347\n"); + end + x = 64'hC340000001FFFBFF; y = 64'h4010000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000002; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'hC360000001FFFBFF; rn = 1; rz = 0; rm = 0; @@ -31480,12 +97938,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1347365\n"); + $fwrite(fp,"1278961\n"); end - x = 64'hC3D401674FDC0C53; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h3817CDE6162EB580; - ans = 64'hC40401674FDC0C52; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h37F0F632AC29B9C3; + z = 64'h3FF0007FFFFFF7FF; + ans = 64'h3FF0007FFFFFF7FF; rn = 1; rz = 0; rm = 0; @@ -31527,12 +97985,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1349379\n"); + $fwrite(fp,"1279575\n"); end - x = 64'h405CA61FE7E505E2; - y = 64'h3F30EFBB517C2470; - z = 64'h8B60000004000003; - ans = 64'h3F9E5360CBF9236A; + x = 64'h3FEB152BF5A33E69; + y = 64'h4010000000000001; + z = 64'h3800400000004000; + ans = 64'h400B152BF5A33E6B; rn = 1; rz = 0; rm = 0; @@ -31574,12 +98032,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1351393\n"); + $fwrite(fp,"1280189\n"); end - x = 64'h3FEFFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h43C02D27FC4AB999; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h43C02D27FC4AB998; rn = 1; rz = 0; rm = 0; @@ -31621,12 +98079,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1353407\n"); + $fwrite(fp,"1280803\n"); end - x = 64'h033DB2D386A2A816; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h46B0010000FFFFFE; - ans = 64'h46B0010000FFFFFE; + x = 64'h411FFFFFFF80FFFF; + y = 64'hC1FFFFFFFFF7F7FF; + z = 64'h373C000400000000; + ans = 64'hC32FFFFFFF78F7FE; rn = 1; rz = 0; rm = 0; @@ -31668,12 +98126,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1355421\n"); + $fwrite(fp,"1281417\n"); end - x = 64'h002FFFFFFFDFEFFE; - y = 64'h270010000FFFFFFF; - z = 64'hBFFFFFFFE000003F; - ans = 64'hBFFFFFFFE000003F; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h4340000000000000; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h433FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -31715,292 +98173,10 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1357435\n"); + $fwrite(fp,"1282031\n"); end - x = 64'h3FEFFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1359449\n"); - end - x = 64'hC0A48931C5AB7A58; - y = 64'h800FFFFFFFFFFFFF; - z = 64'h3FC00007FFFFFDFE; - ans = 64'h3FC00007FFFFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1361463\n"); - end - x = 64'hA0BFFFFFFDFFFFF0; - y = 64'h46AD4FFFD6676AA5; - z = 64'h977FFFFFFF800FFF; - ans = 64'hA77D4FFFD4926A99; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1363477\n"); - end - x = 64'h3FEFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1365491\n"); - end - x = 64'h434FE000FFFFFFFF; - y = 64'hBCA0000000000001; - z = 64'h3FA600A985274F0B; - ans = 64'hBFFF2FFBB3D6C589; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1367505\n"); - end - x = 64'h43C567CDE92A1DFD; - y = 64'hB8000203FFFFFFFE; - z = 64'h3EE00000007FDFFF; - ans = 64'h3EE00000007FDFF4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1369519\n"); - end - x = 64'h3FEFFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFF; + x = 64'hBF900000003FFFFE; + y = 64'h3FA081FFFFFFFFFF; z = 64'hC340000000000000; ans = 64'hC340000000000000; rn = 1; @@ -32044,12 +98220,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1371533\n"); + $fwrite(fp,"1282645\n"); end - x = 64'h40300100000001FF; - y = 64'hBFE0000000000001; - z = 64'hB7EDF5A886053A5C; - ans = 64'hC020010000000200; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h4340000000000001; + z = 64'hC1EFC0003FFFFFFF; + ans = 64'h433FFFFF01FFFE01; rn = 1; rz = 0; rm = 0; @@ -32091,12 +98267,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1373547\n"); + $fwrite(fp,"1283259\n"); end - x = 64'h400000400003FFFF; - y = 64'h3FDFF01FFFFFFFFF; - z = 64'h001C0000000001FE; - ans = 64'h3FEFF09FC087FC05; + x = 64'h3FD0020020000000; + y = 64'h4B50000010000007; + z = 64'h41E00FFFFFFFBFFF; + ans = 64'h4B30020030020027; rn = 1; rz = 0; rm = 0; @@ -32138,12 +98314,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1375561\n"); + $fwrite(fp,"1283873\n"); end - x = 64'h3FEFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + x = 64'hB7EFFFFBFFFFFFF7; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; rn = 1; rz = 0; rm = 0; @@ -32185,12 +98361,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1377575\n"); + $fwrite(fp,"1284487\n"); end - x = 64'h97A7FFFFFFBFFFFF; - y = 64'hC000000000000001; - z = 64'h8000200000000020; - ans = 64'h17B7FFFFFFC00000; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC133A27B1EA10710; + z = 64'h47E1000200000000; + ans = 64'h47E1000200000000; rn = 1; rz = 0; rm = 0; @@ -32232,246 +98408,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1379589\n"); + $fwrite(fp,"1285101\n"); end - x = 64'hBCAFFFFFEFFF0000; - y = 64'hBD20080000FFFFFF; - z = 64'hC3E000000FFFFFF8; - ans = 64'hC3E000000FFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1381603\n"); - end - x = 64'h3FEFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1383617\n"); - end - x = 64'hC34000000000040E; - y = 64'hC340000000000000; - z = 64'hC04FC01FFFFFFFFE; - ans = 64'h469000000000040E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1385631\n"); - end - x = 64'h002D10706BA03B55; - y = 64'h3FC00002FFFFFFFE; - z = 64'h483569E1B1DB2A67; - ans = 64'h483569E1B1DB2A67; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1387645\n"); - end - x = 64'h3FEFFFFFFFFFFFFE; - y = 64'hFFE0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1389659\n"); - end - x = 64'hC2BFFFFFFFBFFBFF; - y = 64'hFFF0000000000000; - z = 64'h4023FFFFFFFFFFFA; + x = 64'h40500008001FFFFF; + y = 64'h7FE0000000000000; + z = 64'h3DC0007BFFFFFFFF; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -32514,12 +98455,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1391673\n"); + $fwrite(fp,"1285715\n"); end - x = 64'h41F000007FFFFBFE; - y = 64'h3FEF177822A30420; - z = 64'hC0A0001040000000; - ans = 64'h41EF17781B5DB96B; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC20EBA2FF0240962; + z = 64'h8000000000000000; + ans = 64'hC20EBA2FF0240961; rn = 1; rz = 0; rm = 0; @@ -32561,12 +98502,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1393687\n"); + $fwrite(fp,"1286329\n"); end - x = 64'h3FF0000000000000; - y = 64'h0000000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + x = 64'h41F0000000FFFF80; + y = 64'hBFB00000800003FE; + z = 64'h406FFF80000007FF; + ans = 64'hC1AFFFFF0208070C; rn = 1; rz = 0; rm = 0; @@ -32608,670 +98549,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1395701\n"); + $fwrite(fp,"1286943\n"); end - x = 64'hC7F00000007FFFE0; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hBFDFFFFFFEFFFBFF; - ans = 64'hBFDFFFFFFEFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1397715\n"); - end - x = 64'h3FF0000000005000; - y = 64'h00100001F0000000; - z = 64'hC3F5CFC170570406; - ans = 64'hC3F5CFC170570406; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1399729\n"); - end - x = 64'h3FF0000000000000; - y = 64'h3CA0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1401743\n"); - end - x = 64'h42C2000001FFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h3FDFF80000002000; - ans = 64'h3FE0440000081000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1403757\n"); - end - x = 64'h4010000007F7FFFE; - y = 64'h8029B242064AB31E; - z = 64'h3FBFFFFF001FFFFE; - ans = 64'h3FBFFFFF001FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1405771\n"); - end - x = 64'h3FF0000000000000; - y = 64'h3FE0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1407785\n"); - end - x = 64'h47BFFFFFFFEFFE00; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'hEA1000200000003E; - ans = 64'hEA1000200000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1409799\n"); - end - x = 64'h3FBFFFFFE01FFFFE; - y = 64'h60DFFFEFFFBFFFFF; - z = 64'hBF0FFFFFF7FFF7FE; - ans = 64'h60AFFFEFDFE00FED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1411813\n"); - end - x = 64'h3FF0000000000000; - y = 64'h4000000000000000; - z = 64'h3FF0000000000001; - ans = 64'h4008000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1413827\n"); - end - x = 64'hC02CE0C00CAC853F; - y = 64'h400FFFFFFFFFFFFF; - z = 64'hC36FFFC0000FFFFE; - ans = 64'hC36FFFC000100005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1415841\n"); - end - x = 64'h41DFFFFFFFFFFF1F; - y = 64'hCEE1FFFFFFFFFBFE; - z = 64'hC9CFFFFFFFFFFFFE; - ans = 64'hD0D1FFFFFFFFFB7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1417855\n"); - end - x = 64'h3FF0000000000000; - y = 64'h401FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1419869\n"); - end - x = 64'h3FCFFFFFFFE00800; - y = 64'h434FFFFFFFFFFFFF; - z = 64'h4F800003FFFDFFFF; - ans = 64'h4F800003FFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1421883\n"); - end - x = 64'hBCAFFFFFFFFFEFFC; - y = 64'h216FFFF00000007F; - z = 64'h48070BD481024D09; - ans = 64'h48070BD481024D09; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1423897\n"); - end - x = 64'h3FF0000000000000; + x = 64'h3FEFFFFFFFFFFFFF; y = 64'h7FEFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + z = 64'h0010000000000000; + ans = 64'h7FEFFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -33313,11 +98596,152 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1425911\n"); + $fwrite(fp,"1287557\n"); end - x = 64'hC3D0000000FFFFFB; + x = 64'h40200000007FFEFE; + y = 64'hBF90000000FFDFFF; + z = 64'hC010000000000001; + ans = 64'hC0108000000BFEF9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1288171\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h7FF0000000000000; + z = 64'h41E8000000000080; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1288785\n"); + end + x = 64'h4340000000010001; + y = 64'h380FFFFFFFDEFFFF; + z = 64'h301000000000207F; + ans = 64'h3B5FFFFFFFE10001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1289399\n"); + end + x = 64'h40AFFFBFFFFE0000; y = 64'h7FFFFFFFFFFFFFFF; - z = 64'h400000000040000F; + z = 64'h3FD0000000000001; ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -33360,12 +98784,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1427925\n"); + $fwrite(fp,"1290013\n"); end - x = 64'h41DFEF145604B84F; - y = 64'h3DAC1CF43ACD55BE; - z = 64'hB365D3A97C96806B; - ans = 64'h3F9C0E16B6B8B351; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBCA7FFFFFFFFFEFF; + z = 64'h070FE00000000800; + ans = 64'hBCA7FFFFFFFFFEFE; rn = 1; rz = 0; rm = 0; @@ -33407,10 +98831,339 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1429939\n"); + $fwrite(fp,"1290627\n"); end - x = 64'h3FF0000000000000; + x = 64'hF5FFFFFFFDDFFFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h5D8FFFFFFDFFFFFD; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1291241\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBFEC736A2BE2AD7C; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1291855\n"); + end + x = 64'hBFE80000001FFFFE; + y = 64'h4014000000200000; + z = 64'h41CE092D9BE1AC67; + ans = 64'h41CE092D9A01AC67; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1292469\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h0000000000000001; + ans = 64'h800FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1293083\n"); + end + x = 64'hBF30004000000008; + y = 64'h41CFFBFFEFFFFFFE; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC10FFC9FDFFFC00E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1293697\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; y = 64'h800FFFFFFFFFFFFE; + z = 64'hA250000000000802; + ans = 64'hA250000000000802; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1294311\n"); + end + x = 64'h5650000007FF7FFF; + y = 64'hBF0FFFFFFDBFFFFE; + z = 64'h7FE0000000FFFEFF; + ans = 64'h7FE0000000FFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1294925\n"); + end + x = 64'hBE2000000000006F; + y = 64'h8010000000000001; z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; @@ -33454,12 +99207,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1431953\n"); + $fwrite(fp,"1295539\n"); end - x = 64'h3FF0000000010006; - y = 64'h8010000000000001; - z = 64'h801F7FFFFFFFFFFF; - ans = 64'h8027C00000008003; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h384007FFFE000000; + z = 64'hBF8801FFFFFFFFFE; + ans = 64'hBF8801FFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -33501,12 +99254,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1433967\n"); + $fwrite(fp,"1296153\n"); end - x = 64'hFFFBA44D53A606C1; - y = 64'h43E0001000000100; - z = 64'hC0300007FFFDFFFE; - ans = 64'hFFFBA44D53A606C1; + x = 64'h3C48C93EA9A07ED5; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hBFF0000FFFFFFFEF; + ans = 64'hBFF0000FFFFFFFEF; rn = 1; rz = 0; rm = 0; @@ -33548,12 +99301,200 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1435981\n"); + $fwrite(fp,"1296767\n"); end - x = 64'h3FF0000000000000; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h4E30000200FFFFFF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1297381\n"); + end + x = 64'hB7FBD8C8068C6E0C; + y = 64'h3EC0CCF1D11F2D71; + z = 64'h37E1FFFFFFFEFFFE; + ans = 64'h37E1FFF8B0A0C977; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1297995\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBCA0000000000000; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1298609\n"); + end + x = 64'h41A01BFFFFFFFFFF; + y = 64'hB14000000100001E; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1299223\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000002; + z = 64'h8A5100000007FFFE; + ans = 64'hBCAFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -33595,12 +99536,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1437995\n"); + $fwrite(fp,"1299837\n"); end - x = 64'hC3FFFFFFF003FFFE; + x = 64'hC02CF7239E657AB3; + y = 64'hC02133A02874B10A; + z = 64'hC340000020000003; + ans = 64'hC34000001FFFFFC5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1300451\n"); + end + x = 64'hC01FFEFFE0000000; + y = 64'hBFD0000000000000; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h3FFFFEFFE0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1301065\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC0000000001FDFFF; + z = 64'h3FB0200000000004; + ans = 64'hBFFEFE00003FBFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1301679\n"); + end + x = 64'hC3F000000013FFFF; y = 64'hBFD0000000000001; - z = 64'hD5C00008000007FF; - ans = 64'hD5C00008000007FF; + z = 64'hFFFFEFFFFFFFE000; + ans = 64'hFFFFEFFFFFFFE000; rn = 1; rz = 0; rm = 0; @@ -33642,12 +99724,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1440009\n"); + $fwrite(fp,"1302293\n"); end - x = 64'h63FD9936CEA127DA; - y = 64'hC6D0000009FFFFFF; - z = 64'hBFE0007FFFFFFF00; - ans = 64'hEADD9936E120EA19; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h97800000000007FE; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -33689,12 +99771,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1442023\n"); + $fwrite(fp,"1302907\n"); end - x = 64'h3FF0000000000000; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFF; + x = 64'hC8002250949885EE; + y = 64'hBDD0000000400002; + z = 64'h38B08007FFFFFFFE; + ans = 64'h45E0225094D90F32; rn = 1; rz = 0; rm = 0; @@ -33736,12 +99818,294 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1444037\n"); + $fwrite(fp,"1303521\n"); end - x = 64'h4063FFDFFFFFFFFF; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1304135\n"); + end + x = 64'h7FF020FFFFFFFFFE; + y = 64'h4B1007FFFFFFFDFF; + z = 64'hBFF0000000000000; + ans = 64'h7FF820FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1304749\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBFE0000000000001; + z = 64'h19CD37F4AB573BAD; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1305363\n"); + end + x = 64'h3FD7F4759BBC33AC; + y = 64'h0001FFF7FFFFFFFE; + z = 64'hC47A74EAEF324D40; + ans = 64'hC47A74EAEF324D40; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1305977\n"); + end + x = 64'hC4300000000801FF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h0010000000000000; + ans = 64'h44300000000801FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1306591\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC3E9F02373D523CF; + z = 64'h434FFFFFFFDFFF7E; + ans = 64'hC3E9E82373D52BCE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1307205\n"); + end + x = 64'h3FB8102FC1161058; y = 64'hBFF0000000000000; - z = 64'hC78AE48A8E9C7B11; - ans = 64'hC78AE48A8E9C7B11; + z = 64'h471FFFFFFFFFBFF7; + ans = 64'h471FFFFFFFFFBFF7; rn = 1; rz = 0; rm = 0; @@ -33783,12 +100147,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1446051\n"); + $fwrite(fp,"1307819\n"); end - x = 64'hBD37F0CA9648274B; - y = 64'h400FFFFFFF0000FF; - z = 64'h802000007FFBFFFF; - ans = 64'hBD57F0CA9588A1B5; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC0A9793A9BECD88F; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFF343; rn = 1; rz = 0; rm = 0; @@ -33830,12 +100194,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1448065\n"); + $fwrite(fp,"1308433\n"); end - x = 64'h3FF0000000000000; - y = 64'hC000000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + x = 64'hC7FFDFFFFFBFFFFF; + y = 64'hC390000003FFFFFD; + z = 64'hBF4FFFFFF000FFFE; + ans = 64'h4B9FE00007B7FFF9; rn = 1; rz = 0; rm = 0; @@ -33877,12 +100241,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1450079\n"); + $fwrite(fp,"1309047\n"); end - x = 64'h400FFFFFFFFFFFFE; - y = 64'hC010000000000000; - z = 64'hC80F001FFFFFFFFF; - ans = 64'hC80F001FFFFFFFFF; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; rn = 1; rz = 0; rm = 0; @@ -33924,12 +100288,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1452093\n"); + $fwrite(fp,"1309661\n"); end - x = 64'hBB70000040000000; - y = 64'hAB3FFFFFFFFFFFF0; - z = 64'h3FCFBFFEFFFFFFFF; - ans = 64'h3FCFBFFEFFFFFFFF; + x = 64'hB6C7632F24A774E2; + y = 64'hBFC000200000001F; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; rn = 1; rz = 0; rm = 0; @@ -33971,12 +100335,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1454107\n"); + $fwrite(fp,"1310275\n"); end - x = 64'h3FF0000000000000; - y = 64'hC340000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC340000000000001; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC000000000000000; + z = 64'hC177FCA22F433E8D; + ans = 64'hC177FCA24F433E8D; rn = 1; rz = 0; rm = 0; @@ -34018,12 +100382,717 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1456121\n"); + $fwrite(fp,"1310889\n"); end - x = 64'hBFBFFFF0000FFFFF; + x = 64'hC1CFFFFFFFFFF5FF; + y = 64'hBFB0000000FFFDFE; + z = 64'h3FAFFFFE00000040; + ans = 64'h41900000013FF8F9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1311503\n"); + end + x = 64'h45CFE0000000007F; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h0000000000000001; + ans = 64'hC5EFE0000000007E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1312117\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h801A837F2AE19C47; + z = 64'h4020800000000007; + ans = 64'h4020800000000007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1312731\n"); + end + x = 64'hC7FFFFC000000001; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hC3C0F052C00D8DA7; + ans = 64'h481FFFBFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1313345\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC1E16294F17A2FC0; + z = 64'h4010000000000001; + ans = 64'hC1E16294F0FA2FBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1313959\n"); + end + x = 64'hBCBC000000000000; + y = 64'h4100000001040000; + z = 64'h401000FFFFFFE000; + ans = 64'h401000FFFFFF0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1314573\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC010000000000001; + z = 64'hC340000000000001; + ans = 64'hC340000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1315187\n"); + end + x = 64'h3F70000000201FFF; + y = 64'h363008000000FFFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1315801\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hC3471DB14B06DAD6; + ans = 64'hC3471DB14B06DADA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1316415\n"); + end + x = 64'hC1FF3AD94ADF7008; + y = 64'h3FCF000000000002; + z = 64'hC071000000000200; + ans = 64'hC1DE4102C488748A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1317029\n"); + end + x = 64'hEEBE30496FC34DC3; + y = 64'hC340000000000000; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1317643\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBFDFF8000003FFFF; + z = 64'h9DBFFFFE003FFFFF; + ans = 64'hBFDFF8000003FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1318257\n"); + end + x = 64'h401C285C5FADB760; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hBA5FFFFE0000003F; + ans = 64'hC37C285C5FADB75F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1318871\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h3B70000400FFFFFF; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1319485\n"); + end + x = 64'h40100FFFFFFFFFFE; + y = 64'h14B0001FFFFFFFFF; + z = 64'hC1C02FFFFFFFFFFF; + ans = 64'hC1C02FFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1320099\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; y = 64'hFFE0000000000000; - z = 64'hB80FF003FFFFFFFF; - ans = 64'h7FAFFFF0000FFFFF; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hFFDFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -34065,12 +101134,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1458135\n"); + $fwrite(fp,"1320713\n"); end - x = 64'h40278F9EB19E2877; - y = 64'h800C3F9986C3ABCE; - z = 64'h380FFFFFF8080000; - ans = 64'h380FFFFFF8080000; + x = 64'hAEF00000047FFFFF; + y = 64'hC017FFFFFFFFFFFC; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -34112,11 +101181,199 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1460149\n"); + $fwrite(fp,"1321327\n"); end - x = 64'h3FF0000000000000; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hBFC0100000400000; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1321941\n"); + end + x = 64'hC1E0000000400100; + y = 64'h355FFFF80000007F; + z = 64'h41D359926AF53F43; + ans = 64'h41D359926AF53F43; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1322555\n"); + end + x = 64'h480000000001FF7E; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1323169\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hE06FFFFFFF00001E; + z = 64'h3E2EE32E2DA9DA61; + ans = 64'hE06FFFFFFF00001D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1323783\n"); + end + x = 64'hBE843F1957410156; y = 64'hFFF0000000000001; - z = 64'h3FF0000000000001; + z = 64'h0000020000001000; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -34159,11 +101416,105 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1462163\n"); + $fwrite(fp,"1324397\n"); end - x = 64'hC0F01FFFFFDFFFFF; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h43FFFFFFC0000400; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h43FFFFFFC00003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1325011\n"); + end + x = 64'h3FBFFFFF000003FE; + y = 64'hBFF007FFFFC00000; + z = 64'h3FA0000000001008; + ans = 64'hBFB80FFEFEFFFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1325625\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h40500100000FFFFE; + z = 64'hC00FFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -34206,12 +101557,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1464177\n"); + $fwrite(fp,"1326239\n"); end - x = 64'hC80E1FFFFFFFFFFE; - y = 64'h43FFF800000FFFFF; - z = 64'hFFE45DEC7D877F1E; - ans = 64'hFFE45DEC7D877F1E; + x = 64'h41C4A5EB10FE5857; + y = 64'h402FFFFFFE0001FF; + z = 64'hBCA0000000000000; + ans = 64'h4204A5EB0FB3FAF0; rn = 1; rz = 0; rm = 0; @@ -34253,12 +101604,200 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1466191\n"); + $fwrite(fp,"1326853\n"); end - x = 64'h3FF0000000000001; + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h0000000000000001; + z = 64'h28D30F43996477D5; + ans = 64'h28D30F43996477D5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1327467\n"); + end + x = 64'h6DB0000004000001; + y = 64'hBFCE75F930ACC3A2; + z = 64'hC1EFFFFFE1FFFFFF; + ans = 64'hED8E75F9384A41F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1328081\n"); + end + x = 64'hBFEF7FFFFFFBFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1328695\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h4020000000800008; + z = 64'hC80FF807FFFFFFFF; + ans = 64'hC80FF807FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1329309\n"); + end + x = 64'h433FFFFFF0000008; y = 64'h0010000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + z = 64'h47EFF00000000100; + ans = 64'h47EFF00000000100; rn = 1; rz = 0; rm = 0; @@ -34300,12 +101839,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1468205\n"); + $fwrite(fp,"1329923\n"); end - x = 64'h403FFFFFF7FFFFFD; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h40055A4532CA591F; - ans = 64'h40055A4532CA591F; + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h43F003FFFFE00000; + z = 64'h3FF0000000000000; + ans = 64'h43F003FFFFDFFFFF; rn = 1; rz = 0; rm = 0; @@ -34347,12 +101886,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1470219\n"); + $fwrite(fp,"1330537\n"); end - x = 64'h117FFFFFFFFF7EFF; - y = 64'h063EFDF9A33EF277; - z = 64'h001FFFFC000FFFFF; - ans = 64'h001FFFFC000FFFFF; + x = 64'hC0200000000200FF; + y = 64'hBFC000000007FFE0; + z = 64'hFD10207FFFFFFFFE; + ans = 64'hFD10207FFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -34394,10 +101933,903 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1472233\n"); + $fwrite(fp,"1331151\n"); end - x = 64'h3FF0000000000001; - y = 64'h3FD0000000000000; + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1331765\n"); + end + x = 64'hAEA2D2DFA3D2A4D3; + y = 64'hC1700080000007FF; + z = 64'h8010000000000001; + ans = 64'h3022D3763ACFCCD0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1332379\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h3CA0000000000000; + z = 64'h4A83FFFFBFFFFFFE; + ans = 64'h4A83FFFFBFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1332993\n"); + end + x = 64'hB5A541B1DC1A499A; + y = 64'h3DDFFFF000000080; + z = 64'h8010D30DDE0007DB; + ans = 64'hB39541A73B415BE2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1333607\n"); + end + x = 64'h3D0FFFFFFFFFF010; + y = 64'h3CA0000000000001; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1334221\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h3FC004000000003E; + z = 64'h47F742E3F90D4517; + ans = 64'h47F742E3F90D4517; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1334835\n"); + end + x = 64'h8FBFF78000000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hC1F8000000000400; + ans = 64'hC1F8000000000400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1335449\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h43FFFFFFF801FFFE; + z = 64'h3FE0000000000001; + ans = 64'h43FFFFFFF801FFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1336063\n"); + end + x = 64'h4063FFFFFFFF0000; + y = 64'hC39FFFFFF8000000; + z = 64'h3FDDFFFFEFFFFFFF; + ans = 64'hC413FFFFFAFF0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1336677\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h3FD0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFE8000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1337291\n"); + end + x = 64'h484FFFFFFEFFDFFE; + y = 64'h43DFFFFFFFFFFFFA; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h4C3FFFFFFEFFDFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1337905\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hBFFAADFFB24BA446; + ans = 64'hBFF2ADFFB24BA447; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1338519\n"); + end + x = 64'h3CDFFFFFFFFFFE1F; + y = 64'h406000FFFFC00000; + z = 64'h39D8B0F072271B05; + ans = 64'h3D5000FFFFBFFF10; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1339133\n"); + end + x = 64'hC3FC000003FFFFFF; + y = 64'h3FE0000000000000; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC3EC000003FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1339747\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hCA6F7FFFFFFFDFFF; + z = 64'hCAEDFFFFFFF7FFFF; + ans = 64'hCAEE1F7FFFF7FFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1340361\n"); + end + x = 64'hC1C0100000001FFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hBC0F7F3C05E5F2B0; + ans = 64'hC1C0100000001FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1340975\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hA4638C58500B961E; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1341589\n"); + end + x = 64'h2EF200000000FFFF; + y = 64'h3CA0800003FFFFFF; + z = 64'hBFC8001000000000; + ans = 64'hBFC8001000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1342203\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h3FF0000000000000; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1342817\n"); + end + x = 64'hBFE118C580AAF9EC; + y = 64'h000F808000000000; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -34441,153 +102873,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1474247\n"); + $fwrite(fp,"1343431\n"); end - x = 64'h000454B2B3078D3E; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'hC1C3FFFFFFDFFFFF; - ans = 64'hC1C3FFFFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1476261\n"); - end - x = 64'hBF71BFB471D6B240; - y = 64'hC3CEFFFFFFFFFFF7; - z = 64'h41FFFFC000000001; - ans = 64'h435131B74E46FCA9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1478275\n"); - end - x = 64'h3FF0000000000001; - y = 64'h3FF0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3FF0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1480289\n"); - end - x = 64'hC3D00000FFFFFFF8; + x = 64'h3FEFFFFFFFFFFFFE; y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFBFFFFF6; - ans = 64'h7FFFFFFFFBFFFFF6; + z = 64'hA79000000003FF7F; + ans = 64'h3FFFFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -34629,12 +102920,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1482303\n"); + $fwrite(fp,"1344045\n"); end - x = 64'h3FE919F7AC33ADBE; - y = 64'h4060003000000000; - z = 64'h47646D77AB0D9F00; - ans = 64'h47646D77AB0D9F00; + x = 64'h401FFDFFFFEFFFFE; + y = 64'h0AD00000000003EE; + z = 64'hA4CBFFFFFFFFFF7F; + ans = 64'hA4CBFFFFFFFFFF7F; rn = 1; rz = 0; rm = 0; @@ -34676,12 +102967,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1484317\n"); + $fwrite(fp,"1344659\n"); end - x = 64'h3FF0000000000001; + x = 64'h4D4000000000201F; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'h4D5000000000201E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1345273\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hD69C0000000000FF; + z = 64'h43D00000000007FC; + ans = 64'hD69C0000000000FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1345887\n"); + end + x = 64'hBF95B034FF94FE5C; + y = 64'h4000000000000001; + z = 64'h40BCE22B0AAE2F5F; + ans = 64'h40BCE2203293AF95; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1346501\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hE8240000000FFFFF; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'hE8240000000FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1347115\n"); + end + x = 64'h0C1E96E5A8F1725B; + y = 64'h41FF800000003FFF; + z = 64'h3FDF000100000000; + ans = 64'h3FDF000100000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1347729\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; y = 64'h400FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'h4007FFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h400BFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -34723,12 +103249,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1486331\n"); + $fwrite(fp,"1348343\n"); end - x = 64'h3D80000800003FFF; + x = 64'hCFBFFF00000FFFFF; + y = 64'h40DC8DDCCA9532BF; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1348957\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h4010000000000001; + z = 64'h409FFF7FFFDFFFFE; + ans = 64'h40A007BFFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1349571\n"); + end + x = 64'hB7F000000000FFF7; + y = 64'h7FD00003FFFFFFEF; + z = 64'h4110004040000000; + ans = 64'hF7D000040000FFE6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1350185\n"); + end + x = 64'hFFEFFDFFFFFE0000; y = 64'h401FFFFFFFFFFFFF; - z = 64'h3B40000000000037; - ans = 64'h3DB0000800005FFE; + z = 64'hC000000000000000; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -34770,12 +103437,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1488345\n"); + $fwrite(fp,"1350799\n"); end - x = 64'hBA2DFFFFFFFFFFFB; - y = 64'hB7E70CD81A296791; - z = 64'h419A49C35CF1439E; - ans = 64'h419A49C35CF1439E; + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h3FEFF00000000FFF; + z = 64'h41FFFFFDFFFFF7FF; + ans = 64'h41FFFFFE000FEFFF; rn = 1; rz = 0; rm = 0; @@ -34817,12 +103484,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1490359\n"); + $fwrite(fp,"1351413\n"); end - x = 64'h3FF0000000000001; - y = 64'h434FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4358000000000000; + x = 64'h3FFFFFFFFFFFFFF7; + y = 64'h4340000000000000; + z = 64'hBB4FFFFBFFFFE000; + ans = 64'h434FFFFFFFFFFFF7; rn = 1; rz = 0; rm = 0; @@ -34864,12 +103531,294 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1492373\n"); + $fwrite(fp,"1352027\n"); end - x = 64'h8EA000800007FFFE; + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h3D20000007FFFFFE; + z = 64'h3CA0000000000000; + ans = 64'h3D20100007FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1352641\n"); + end + x = 64'h3C10004003FFFFFF; + y = 64'h3F0D38A39B792D42; + z = 64'h002C000000FFFFFF; + ans = 64'h3B2D39188555C40C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1353255\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hBFD0000000000000; + ans = 64'h434FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1353869\n"); + end + x = 64'hBFCFFF8000FFFFFF; + y = 64'h000F800000000007; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1354483\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h7FE0000000000000; + z = 64'h480FFF0003FFFFFE; + ans = 64'h7FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1355097\n"); + end + x = 64'hC0100401FFFFFFFF; + y = 64'h47F479040FA5F423; + z = 64'hC0A638D6A77E342F; + ans = 64'hC8147E24DFCA5F93; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1355711\n"); + end + x = 64'h47F0007FF8000000; y = 64'h7FE0000000000001; - z = 64'hCC6000000200000F; - ans = 64'hCE9000800009FFFF; + z = 64'hBFF0000000000001; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -34911,12 +103860,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1494387\n"); + $fwrite(fp,"1356325\n"); end - x = 64'h4000010000000000; - y = 64'hBBB3FFFFDFFFFFFF; - z = 64'h3FD4000000000000; - ans = 64'h3FD4000000000000; + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h403E000001FFFFFF; + z = 64'h4020008000000000; + ans = 64'h4043002000FFFFFF; rn = 1; rz = 0; rm = 0; @@ -34958,11 +103907,7249 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1496401\n"); + $fwrite(fp,"1356939\n"); end - x = 64'h3FF0000000000001; - y = 64'h7FFFFFFFFFFFFFFF; + x = 64'hC550008000007FFE; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h3F80000010000800; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1357553\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h469FFFEFFFFFFFBE; + z = 64'h0010000000000001; + ans = 64'h469FFFEFFFFFFFBC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1358167\n"); + end + x = 64'h401FFFF7FFFFFFFA; + y = 64'h40CF9BE39E1FA5EE; + z = 64'hB80010000003FFFF; + ans = 64'h40FF9BDBB726BE60; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1358781\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h7FF0000000000001; + z = 64'hBCA0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1359395\n"); + end + x = 64'h3FD00003FBFFFFFF; + y = 64'h7FEFFFFFFFE07FFE; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h7FD00003FBF03FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1360009\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hBCAFFFEFFFFFFF7F; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1360623\n"); + end + x = 64'h4020040000100000; + y = 64'hF7601000000000FF; + z = 64'h41CFFFFFFFFFBFE0; + ans = 64'hF7901404001010FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1361237\n"); + end + x = 64'hD927210495182481; + y = 64'h8000000000000000; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1361851\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h381FFFFFFFFBFFFF; + z = 64'h3FC0100001FFFFFF; + ans = 64'h3FC0100001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1362465\n"); + end + x = 64'hD741116F2A3365CB; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC06000001FC00000; + ans = 64'hC06000001FC00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1363079\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hBFD00000007FFFFD; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hBFD00000007FFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1363693\n"); + end + x = 64'hC1F000007EFFFFFF; + y = 64'hC3DFFFFFFFDFFEFF; + z = 64'hC34C07FFFFFFFFFE; + ans = 64'h45E000007EEFF87C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1364307\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h8010000000000000; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h8027FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1364921\n"); + end + x = 64'hFFDD48F3ED90B012; + y = 64'hC26FFF83FFFFFFFE; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1365535\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h800007FFFFFBFFFE; + ans = 64'h802003FFFFFDFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1366149\n"); + end + x = 64'hC3FF3FFFFFFFFFFE; + y = 64'h43DFFFFDFFFF7FFF; + z = 64'hB4FFFFBFBFFFFFFF; + ans = 64'hC7EF3FFE0BFF82FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1366763\n"); + end + x = 64'hC01FFFFFFAFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1367377\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hC01000FFFFFEFFFF; + z = 64'hC34FFFFFFFF803FE; + ans = 64'hC34FFFFFFFF80400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1367991\n"); + end + x = 64'h40B00000001FFBFF; + y = 64'hBCA0000000000001; + z = 64'hC1F000007FBFFFFE; + ans = 64'hC1F000007FBFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1368605\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h413EFFF800000000; z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1369219\n"); + end + x = 64'hC6300001000FFFFF; + y = 64'h434FFFFFFFC0007F; + z = 64'h3FFFFFFFFFFFEFEF; + ans = 64'hC9900000FFF0003C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1369833\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1370447\n"); + end + x = 64'h4AAF000007FFFFFF; + y = 64'h0004977D373AAD6E; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1371061\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hBFD0000000000001; + z = 64'hBE1001FFFFDFFFFF; + ans = 64'hBFD0000001002000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1371675\n"); + end + x = 64'hBABFF7FFFDFFFFFF; + y = 64'hB9B31D4215104245; + z = 64'hBFD9CAF56DFECE0A; + ans = 64'hBFD9CAF56DFECE0A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1372289\n"); + end + x = 64'h3CA0000000008007; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1372903\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h00200000000001FC; + z = 64'h3F741AB531AC27FD; + ans = 64'h3F741AB531AC27FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1373517\n"); + end + x = 64'hC3D000000000407F; + y = 64'hBFE0000000000000; + z = 64'hBFD1FFFFFFEFFFFF; + ans = 64'h43C000000000407F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1374131\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hC6B0000040000008; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1374745\n"); + end + x = 64'hBFDFFF7FFFFFBFFF; + y = 64'h7DA199373DE9FB0D; + z = 64'h00200001FFFFFFFA; + ans = 64'hFD9198F0D90CE032; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1375359\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h8000000000000000; + ans = 64'hBFEFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1375973\n"); + end + x = 64'h3CFD9E68D58E5F29; + y = 64'h430F52E00863ED5B; + z = 64'h4000000000000001; + ans = 64'h40227F156C138BF2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1376587\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hBFF0000000000000; + z = 64'hC3D00000000000BF; + ans = 64'hC3D00000000000BF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1377201\n"); + end + x = 64'hC1E4000000800000; + y = 64'hE56FC00000000008; + z = 64'hC5B036279681DACA; + ans = 64'h6763D800007F0005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1377815\n"); + end + x = 64'h4033A8D422040365; + y = 64'hBFF0000000000001; + z = 64'hBCA0000000000001; + ans = 64'hC033A8D422040366; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1378429\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hBCE0000040000000; + z = 64'hC340000000040007; + ans = 64'hC340000000040007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1379043\n"); + end + x = 64'hBFFF800400000000; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h8A809F84BB94C49F; + ans = 64'h400F8003FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1379657\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hC03FFFFFFFF0FFFF; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1380271\n"); + end + x = 64'hC1FF310B7E90EE8B; + y = 64'hC02FFFFFFBBFFFFF; + z = 64'hC1F94758E83D6556; + ans = 64'h423D9C95EBE894AE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1380885\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hC000000000000001; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1381499\n"); + end + x = 64'h7FF0656055BFCC7D; + y = 64'hB9D00001FFFFFFFC; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h7FF8656055BFCC7D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1382113\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h3FD000800000007F; + ans = 64'hC00DFFEFFFFFFFEC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1382727\n"); + end + x = 64'hBFCFFC00FFFFFFFF; + y = 64'hC01FFFBFFFBFFFFE; + z = 64'h41DFFFFFFFFFFFFF; + ans = 64'h41E00000003FF782; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1383341\n"); + end + x = 64'hFFD82E04A44D5219; + y = 64'hC010000000000000; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1383955\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h41D0000004007FFF; + z = 64'h47EFFF7FFFFFBFFF; + ans = 64'h47EFFF7FFFFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1384569\n"); + end + x = 64'h47FFFFFFFFFFFFE8; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h7FD002000000007F; + ans = 64'h7FD002000000007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1385183\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h43DFFFFFFFFC0007; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'h43DFEFFFFFFC0005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1385797\n"); + end + x = 64'h800BBE3863B0D8E2; + y = 64'h8D1C310F19AC6C6C; + z = 64'h29A000000001F7FF; + ans = 64'h29A000000001F7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1386411\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hC340000000000000; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1387025\n"); + end + x = 64'h40540000001FFFFF; + y = 64'h7AAAE17574EE89CD; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h7B10CCE9692FF795; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1387639\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hC340000000000001; + z = 64'hBE3774044EEB60EB; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1388253\n"); + end + x = 64'hA0439A60C9F683F6; + y = 64'hC00FFFFFEFEFFFFE; + z = 64'hC7E01000000000FF; + ans = 64'hC7E01000000000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1388867\n"); + end + x = 64'h400000000001FDFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hC36000000001FDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1389481\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h41EFFB7FFFFFFFFE; + z = 64'h7FE0000001FF0000; + ans = 64'h7FE0000001FF0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1390095\n"); + end + x = 64'hBCBFFFFF7FFFFFFF; + y = 64'hFFE0000000000001; + z = 64'hBFEFEFFFFFFFFF7F; + ans = 64'h7CAFFFFF80000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1390709\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hC3E0000000000000; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC3DFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1391323\n"); + end + x = 64'h400B23CD9F2D28D3; + y = 64'h43E00003FFF7FFFF; + z = 64'hB8101BFFFFFFFFFF; + ans = 64'h43FB23D46812FEB6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1391937\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1392551\n"); + end + x = 64'h2CCFFFFFF9000000; + y = 64'h3E6FFFFFFF000FFF; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1393165\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hFFF0000000000000; + z = 64'h800905798199477F; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1393779\n"); + end + x = 64'hB7FFFFFFFFF5FFFF; + y = 64'hBFCFFFFFFF7FFFFC; + z = 64'hC60FDFFFFFFFDFFF; + ans = 64'hC60FDFFFFFFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1394393\n"); + end + x = 64'hD8FF800000000000; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h8000000000000000; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1395007\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h3FB058526BA0D257; + z = 64'h800FFFFE0000007E; + ans = 64'h3FB058526BA0D256; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1395621\n"); + end + x = 64'hB81002000000000E; + y = 64'h0000000000000000; + z = 64'hBC7C2C58541F1160; + ans = 64'hBC7C2C58541F1160; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1396235\n"); + end + x = 64'h3FF0000000000000; + y = 64'hBF1FFFFF7F7FFFFF; + z = 64'hC010000000000000; + ans = 64'hC010001FFFFF7F80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1396849\n"); + end + x = 64'hC768FA865408D1D8; + y = 64'h3D9294A5362769E9; + z = 64'h43FFFFE0000001FE; + ans = 64'hC50D01D665378D9E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1397463\n"); + end + x = 64'h3FF0000000000000; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1398077\n"); + end + x = 64'hB4DCF901BB92E4A0; + y = 64'h3E2FEDFFFFFFFFFF; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1398691\n"); + end + x = 64'h3FF0000000000000; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3D500008000007FE; + ans = 64'h3D500008000007FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1399305\n"); + end + x = 64'h41FDFFFFFFFFFFEF; + y = 64'h606BF7FFFFFFFFFE; + z = 64'h41DCFE3F1CFBA018; + ans = 64'h627A387FFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1399919\n"); + end + x = 64'h4020000804000000; + y = 64'h0010000000000001; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1400533\n"); + end + x = 64'h3FF0000000000000; + y = 64'h8A10800000000003; + z = 64'hBD0FF000FFFFFFFF; + ans = 64'hBD0FF000FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1401147\n"); + end + x = 64'h402FFFFFFF800002; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hC3C8EA6925A562CF; + ans = 64'hC3C8EA6925A562CF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1401761\n"); + end + x = 64'h3FF0000000000000; + y = 64'h381FFEFFFFFFFFFD; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1402375\n"); + end + x = 64'h41C03474E092DF19; + y = 64'hB887A3DBAEE7821E; + z = 64'h43D0000004000003; + ans = 64'h43D0000004000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1402989\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3CA0000000000001; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1403603\n"); + end + x = 64'h3CAFFFFFFF00007E; + y = 64'hCABFFFFFEFFBFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC77FFFFFEEFC007D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1404217\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hAB4FFFFFFFDFFDFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1404831\n"); + end + x = 64'hBFEFFFC0001FFFFF; + y = 64'hC390040000000000; + z = 64'h7FF0000000000060; + ans = 64'h7FF8000000000060; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1405445\n"); + end + x = 64'hEE6001FFFDFFFFFE; + y = 64'h3FD0000000000000; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1406059\n"); + end + x = 64'h3FF0000000000000; + y = 64'h400000000FEFFFFF; + z = 64'h37D3F51830BDE67E; + ans = 64'h400000000FEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1406673\n"); + end + x = 64'hBFF9733FD96151F8; + y = 64'h3FD0000000000001; + z = 64'h7FD9EFD6C4A0DA0E; + ans = 64'h7FD9EFD6C4A0DA0E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1407287\n"); + end + x = 64'h3FF0000000000000; + y = 64'h480EF55E4C511072; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h480EF55E4C511072; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1407901\n"); + end + x = 64'hEDD07FFC00000000; + y = 64'h0CDE33B29AF512B6; + z = 64'h7FF0000000800080; + ans = 64'h7FF8000000800080; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1408515\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3FE0000000000000; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h4012000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1409129\n"); + end + x = 64'h7FEFFFFFFFE7FFFF; + y = 64'h403000FFFFFFFF7F; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1409743\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3FE0000000000001; + z = 64'hC7FFFFFFFF8007FF; + ans = 64'hC7FFFFFFFF8007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1410357\n"); + end + x = 64'hC1EFFFFE007FFFFF; + y = 64'h7E5F7FFFFF000000; + z = 64'hC048000001000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1410971\n"); + end + x = 64'h000FFEEFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1411585\n"); + end + x = 64'h3FF0000000000000; + y = 64'h41AFFFC000FFFFFF; + z = 64'hBFFFFFFE000001FF; + ans = 64'h41AFFFBFFD00003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1412199\n"); + end + x = 64'h43CFF740660B0295; + y = 64'h3FF0000000000000; + z = 64'h3FC97D303536B448; + ans = 64'h43CFF740660B0295; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1412813\n"); + end + x = 64'h3FF0000000000000; + y = 64'h380FEFFFFFFFFF80; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1413427\n"); + end + x = 64'h4511DFFFFFFFFFFF; + y = 64'h401000000010007E; + z = 64'h001FBFFFFFFFFFFE; + ans = 64'h4531E0000011E08C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1414041\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1414655\n"); + end + x = 64'hC46FFFFFF801FFFF; + y = 64'h5F5FFFFFFC00FFFF; + z = 64'h0010000000000000; + ans = 64'hE3DFFFFFF402FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1415269\n"); + end + x = 64'h3FF0000000000000; + y = 64'h4000000000000000; + z = 64'h36E02000000003FF; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1415883\n"); + end + x = 64'h802FFFFFFFFDFDFF; + y = 64'hA1620FFFFFFFFFFE; + z = 64'h3FFFFFFFBFFFFEFE; + ans = 64'h3FFFFFFFBFFFFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1416497\n"); + end + x = 64'hC1DE99F9DE1E2571; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h433FFFFE1660621E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1417111\n"); + end + x = 64'h3FF0000000000000; + y = 64'h919FFFFFDFBFFFFF; + z = 64'h4A9FFFF7FFFF0000; + ans = 64'h4A9FFFF7FFFF0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1417725\n"); + end + x = 64'hDB31E4BC02F84EE3; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h40000003FFBFFFFE; + ans = 64'hDB51E4BC02F84EE2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1418339\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3806052FB3CF6049; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1418953\n"); + end + x = 64'hC7F0000003F00000; + y = 64'hBF3EFFFFFFFFFFDE; + z = 64'hBF9FFFFFF7FFFFFB; + ans = 64'h473F000007A0FFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1419567\n"); + end + x = 64'h3FF0000000000000; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3FF0000000000000; + ans = 64'h4022000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1420181\n"); + end + x = 64'h7FDFFFFDFFFFFEFF; + y = 64'hC2D5D0A345929279; + z = 64'h0000000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1420795\n"); + end + x = 64'h3FF0000000000000; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h3FF0001FFFFF7FFE; + ans = 64'h40220003FFFFEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1421409\n"); + end + x = 64'hC023FFFFFF7FFFFF; + y = 64'h000FFFFEEFFFFFFF; + z = 64'hC1801FF000000000; + ans = 64'hC1801FF000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1422023\n"); + end + x = 64'h3FD8BF5AE69162C4; + y = 64'h4340000000000001; + z = 64'h4010000000000001; + ans = 64'h4328BF5AE69162CE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1422637\n"); + end + x = 64'h3FF0000000000000; + y = 64'h4070041FFFFFFFFE; + z = 64'hBD807FFFFFFFFFFF; + ans = 64'h4070041FFFFFFFDD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1423251\n"); + end + x = 64'hB7EFFFFEFEFFFFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h816FFFFFFFFFF07E; + ans = 64'hBB4FFFFEFEFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1423865\n"); + end + x = 64'h3FF0000000000000; + y = 64'h47FBFFDFFFFFFFFF; + z = 64'hBFD0000000000001; + ans = 64'h47FBFFDFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1424479\n"); + end + x = 64'h000BC447665234B1; + y = 64'hC1E00000020007FE; + z = 64'hC37FFFFFF87FFFFF; + ans = 64'hC37FFFFFF87FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1425093\n"); + end + x = 64'h3FF0000000000000; + y = 64'h7FE0000000000001; + z = 64'h3FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1425707\n"); + end + x = 64'hC0CF5CA46D9DFF8A; + y = 64'h43D00000004001FF; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1426321\n"); + end + x = 64'h3FF0000000000000; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hC2B20000003FFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1426935\n"); + end + x = 64'h283FFFC0000FFFFF; + y = 64'h47EFC01FFFFFFFFE; + z = 64'hC1D3A57182FEF829; + ans = 64'hC1D3A57182FEF829; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1427549\n"); + end + x = 64'hBA700010007FFFFF; + y = 64'h7FF0000000000000; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1428163\n"); + end + x = 64'h3FF0000000000000; + y = 64'h48000FFFFBFFFFFF; + z = 64'h000FFFC000020000; + ans = 64'h48000FFFFBFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1428777\n"); + end + x = 64'h3CAFF80000003FFF; + y = 64'h7FF0000000000001; + z = 64'h3FB03FFFFFFFFBFE; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1429391\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3FEC0000000001FE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3FEC0000000001FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1430005\n"); + end + x = 64'h4AD000020007FFFF; + y = 64'h419FFF80000003FE; + z = 64'hBCAFFBFFFFFFFBFF; + ans = 64'h4C7FFF84000003BC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1430619\n"); + end + x = 64'h3FF0000000000000; + y = 64'h8000000000000000; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1431233\n"); + end + x = 64'h800D1E2B38A9119F; + y = 64'h434F7FF800000000; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1431847\n"); + end + x = 64'h3FF0000000000000; + y = 64'h8000000000000001; + z = 64'h3B61E24154BF7903; + ans = 64'h3B61E24154BF7903; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1432461\n"); + end + x = 64'hBFEF00000007FFFF; + y = 64'h7FFFFFFDFFFFFFEF; + z = 64'h41CFFFDFFFFFFFF7; + ans = 64'h7FFFFFFDFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1433075\n"); + end + x = 64'h3FBFFFFF7FFF0000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1433689\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3801000200000000; + z = 64'hB90000000FDFFFFE; + ans = 64'hB8FFFFDE1FBBFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1434303\n"); + end + x = 64'hA33FFFFFFFFF000F; + y = 64'h8010000000000000; + z = 64'hC02FFFC100000000; + ans = 64'hC02FFFC100000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1434917\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3FDC0378450D3C17; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h3FDC0378450D3C17; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1435531\n"); + end + x = 64'hC3FF00000000001F; + y = 64'h37FDA4C8F7C83ED8; + z = 64'hC01FC00004000000; + ans = 64'hC01FC00004000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1436145\n"); + end + x = 64'h3FF0000000000000; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1436759\n"); + end + x = 64'h7FF164002DF5273F; + y = 64'h3FEFFFFE08000000; + z = 64'hFFE0000000000000; + ans = 64'h7FF964002DF5273F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1437373\n"); + end + x = 64'h3FF0000000000000; + y = 64'hBCA0000000000000; + z = 64'hFFFF87FFFFFFFFFE; + ans = 64'hFFFF87FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1437987\n"); + end + x = 64'h400000000001FFEE; + y = 64'hC3FFF00000020000; + z = 64'h40F00FE000000000; + ans = 64'hC40FF0000005FDD4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1438601\n"); + end + x = 64'h41FD4494A975008F; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3FF0000000000000; + ans = 64'h3FEFFFFC576D6AD1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1439215\n"); + end + x = 64'h3FF0000000000000; + y = 64'hC4E000008000001F; + z = 64'h4AA0000000002003; + ans = 64'h4AA0000000002003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1439829\n"); + end + x = 64'h40E000040003FFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBFEFF80007FFFFFE; + ans = 64'hBFEFF8000800FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1440443\n"); + end + x = 64'h3FF0000000000000; + y = 64'hFFFBD39E9E23680E; + z = 64'h8010000000000000; + ans = 64'hFFFBD39E9E23680E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1441057\n"); + end + x = 64'h0020200001000000; + y = 64'hC3F7520A4E692CBB; + z = 64'hC3D00000000007FE; + ans = 64'hC3D00000000007FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1441671\n"); + end + x = 64'h3FF0000000000000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h3CA0000000000000; + ans = 64'hBFDFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1442285\n"); + end + x = 64'hCE300008000FFFFF; + y = 64'h3DFFFFFF800007FF; + z = 64'hC340000000000001; + ans = 64'hCC400007C00FE3FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1442899\n"); + end + x = 64'h3FF0000000000000; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h800FFFFFFFFC07FF; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1443513\n"); + end + x = 64'hBFDFFFFFFFFEF7FF; + y = 64'hC80FFFFAFFFFFFFF; + z = 64'h7FE83123594AADF9; + ans = 64'h7FE83123594AADF9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1444127\n"); + end + x = 64'h3FBDE21AFA338D84; + y = 64'hBFE0000000000001; + z = 64'h3FE0000000000001; + ans = 64'h3FDC43BCA0B98E51; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1444741\n"); + end + x = 64'h3FF0000000000000; + y = 64'hAA0159203C3AEEA7; + z = 64'h43E00007FFFFFFF6; + ans = 64'h43E00007FFFFFFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1445355\n"); + end + x = 64'hBFBCCDD2E538BE7C; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hC7FFFFC000000003; + ans = 64'hC7FFFFC000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1445969\n"); + end + x = 64'h3FF0000000000000; + y = 64'hCA0FFFFFFFFFFFE0; + z = 64'h8000000000000001; + ans = 64'hCA0FFFFFFFFFFFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1446583\n"); + end + x = 64'h3EFFFFFFFFFFFF83; + y = 64'hC000000000010010; + z = 64'hC0300008001FFFFE; + ans = 64'hC030000C001FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1447197\n"); + end + x = 64'h3FF0000000000000; + y = 64'hBFF0000000000001; + z = 64'h0010000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1447811\n"); + end + x = 64'h43FFFFFFFFEFFFFE; + y = 64'hC7EBFFFFFFFFFFF7; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hCBFBFFFFFFF1FFF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1448425\n"); + end + x = 64'h3FF0000000000000; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h5B8FFFFC00000040; + ans = 64'h5B8FFFFC00000040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1449039\n"); + end + x = 64'h41C00000023FFFFF; + y = 64'h402FFF8000003FFF; + z = 64'h43EFFFFFF6FFFFFF; + ans = 64'h43EFFFFFF73FFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1449653\n"); + end + x = 64'h3CA6A6F59CD6ED19; + y = 64'hC000000000000000; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFF9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1450267\n"); + end + x = 64'h3FF0000000000000; + y = 64'h062F7D4B3A2E44A3; + z = 64'h1390007FFFFBFFFF; + ans = 64'h1390007FFFFBFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1450881\n"); + end + x = 64'hB5D0000000007FFF; + y = 64'hC000000000000001; + z = 64'h42800000200000FF; + ans = 64'h42800000200000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1451495\n"); + end + x = 64'h3FF0000000000000; + y = 64'hC3F0007FFFFFFFEF; + z = 64'h7FFFFFFFFFFFFFFF; ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -35005,12 +111192,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1498415\n"); + $fwrite(fp,"1452109\n"); end - x = 64'h380FFFFF7DFFFFFE; - y = 64'h8000000000000001; - z = 64'h3757EB54C3BC586F; - ans = 64'h3757EB54C3BC586F; + x = 64'h37FC68F2C9551242; + y = 64'hBFE8000000001000; + z = 64'hC0FFFFFFF7FC0000; + ans = 64'hC0FFFFFFF7FC0000; rn = 1; rz = 0; rm = 0; @@ -35052,12 +111239,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1500429\n"); + $fwrite(fp,"1452723\n"); end - x = 64'hBDDFFF81FFFFFFFF; - y = 64'hBF4FFFFFFFF7FFBE; - z = 64'h0CEFFEDFFFFFFFFE; - ans = 64'h3D3FFF81FFF7FFDD; + x = 64'h3FF0000000000000; + y = 64'hC010000000000000; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hC010000000000000; rn = 1; rz = 0; rm = 0; @@ -35099,10 +111286,6496 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1502443\n"); + $fwrite(fp,"1453337\n"); + end + x = 64'h414000007DFFFFFE; + y = 64'hBFC00000207FFFFE; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC11000109E8000FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1453951\n"); + end + x = 64'h3FF0000000000000; + y = 64'hC010000000000001; + z = 64'hC1FFFFFFFE000001; + ans = 64'hC1FFFFFFFE400001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1454565\n"); + end + x = 64'h42B0007FFFFFFFFF; + y = 64'hB7EBFFFF00000000; + z = 64'hBFDFFFFFFFFFBFFE; + ans = 64'hBFDFFFFFFFFFBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1455179\n"); + end + x = 64'h802B8498753EDE4C; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1455793\n"); + end + x = 64'h3FF0000000000000; + y = 64'hBFF0800000000200; + z = 64'h3FE0082000000000; + ans = 64'hBFE0F7E000000400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1456407\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC340000000000000; + z = 64'hBFD000FBFFFFFFFF; + ans = 64'hC36FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1457021\n"); + end + x = 64'h3FF0000000000000; + y = 64'hC3D001FFFFDFFFFF; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1457635\n"); + end + x = 64'hBCA61E84606C3423; + y = 64'h60BFFFFFFFFFFF9E; + z = 64'hC3D000007FDFFFFF; + ans = 64'hDD761E84606C33DF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1458249\n"); + end + x = 64'h3FF0000000000000; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1458863\n"); + end + x = 64'hC6E007FFFFFFFFFD; + y = 64'h41DD22A3BDB366AB; + z = 64'hC000000000000000; + ans = 64'hC8CD31350F924059; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1459477\n"); + end + x = 64'h3FF0000000000000; + y = 64'hFFE0000000000000; + z = 64'hC02200001FFFFFFE; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1460091\n"); + end + x = 64'hFFE4CA029067CDD2; + y = 64'hC3DBFFDFFFFFFFFF; + z = 64'h465BFFFFFFF7FFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1460705\n"); + end + x = 64'hBFF0009000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h3CA0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1461319\n"); + end + x = 64'h3FF0000000000000; + y = 64'hBFCDFFFFFEFFFFFF; + z = 64'h262981240D4CABCB; + ans = 64'hBFCDFFFFFEFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1461933\n"); + end + x = 64'hB7E0000FFFFFFFEE; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h3FBFFFFFF00003FE; + ans = 64'h77E0000FFFFFFFED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1462547\n"); + end + x = 64'h3FF0000000000000; + y = 64'h5B30000000081FFF; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1463161\n"); + end + x = 64'hBFE0000000000000; + y = 64'h3DBFFFFFFFFFFFFE; + z = 64'hBFE7BC400C829841; + ans = 64'hBFE7BC400C849841; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1463775\n"); + end + x = 64'h3FF0000000000000; + y = 64'hFFF0000000000001; + z = 64'hFFF0000000000000; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1464389\n"); + end + x = 64'hC014558C41993437; + y = 64'h3FFFFFFFFFF80007; + z = 64'hBFF0000000000001; + ans = 64'hC026558C41941ED9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1465003\n"); + end + x = 64'h3FF0000000000000; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h7FDFFEFF7FFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1465617\n"); + end + x = 64'hFFE000100007FFFF; + y = 64'hC1EFFFFFFFFFF9FE; + z = 64'h41EFFFFAFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1466231\n"); + end + x = 64'hBFD0002000007FFF; + y = 64'h0000000000000001; + z = 64'h0010000000000001; + ans = 64'h0010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1466845\n"); end x = 64'h3FF0000000000001; - y = 64'h801FFFFFFFFFFFFF; + y = 64'h401FFFEFFFFFFE00; + z = 64'hB7E0001FFFFFFFF0; + ans = 64'h401FFFEFFFFFFE02; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1467459\n"); + end + x = 64'h4030000800000002; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3FD6420B9320937C; + ans = 64'h3FD6420B9320937C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1468073\n"); + end + x = 64'h3FF0000000000001; + y = 64'hC02FFFFFFF800000; + z = 64'h4340000000000001; + ans = 64'h433FFFFFFFFFFFF2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1468687\n"); + end + x = 64'hC33D09CE5D5C2E97; + y = 64'h37E00000007FFBFF; + z = 64'h3FB0000007FFDFFF; + ans = 64'h3FB0000007FFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1469301\n"); + end + x = 64'h3FF0000000000001; + y = 64'h0010000000000000; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1469915\n"); + end + x = 64'h3CA0003FFFDFFFFF; + y = 64'h51B0001FFFFFE000; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'h4E600060005FDFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1470529\n"); + end + x = 64'h3FF0000000000001; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h41E2741C57480754; + ans = 64'h41E2741C57480754; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1471143\n"); + end + x = 64'hC5C0000400000FFE; + y = 64'h282FFFEFFFFFBFFF; + z = 64'hBE6FFFBFFFFFFFFF; + ans = 64'hBE6FFFBFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1471757\n"); + end + x = 64'hC1FFFFFFFFFFFFBB; + y = 64'h3CA0000000000000; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hBEAFFFFFFFFFFFBB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1472371\n"); + end + x = 64'h3FF0000000000001; + y = 64'h43D8225B6AFE04F2; + z = 64'h3FDFFE00000007FE; + ans = 64'h43D8225B6AFE04F4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1472985\n"); + end + x = 64'hBF9FFFF807FFFFFE; + y = 64'h3CA0000000000001; + z = 64'hBF90002003FFFFFF; + ans = 64'hBF90002004000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1473599\n"); + end + x = 64'h3FF0000000000001; + y = 64'hC30FFDFFFFFFFDFF; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'hC30FFDFFFFFFFDC1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1474213\n"); + end + x = 64'hBED0001000200000; + y = 64'hBFC000000004000E; + z = 64'h434FFFFFFFFFFF01; + ans = 64'h434FFFFFFFFFFF01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1474827\n"); + end + x = 64'h3FF0000000000001; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1475441\n"); + end + x = 64'h3D0FFE7FFFFFFFFE; + y = 64'hBBCE249A24D994EE; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1476055\n"); + end + x = 64'h3FF0000000000001; + y = 64'h3FD0000000000001; + z = 64'h6DBF7BFFFFFFFFFF; + ans = 64'h6DBF7BFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1476669\n"); + end + x = 64'h427FF80001FFFFFF; + y = 64'hB810FFFFFE000000; + z = 64'h4721FBFFFFFFFFFE; + ans = 64'h4721FBFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1477283\n"); + end + x = 64'hC3F0000000200800; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1477897\n"); + end + x = 64'h3FF0000000000001; + y = 64'h403000001FFF0000; + z = 64'h381EFFFFFFBFFFFF; + ans = 64'h403000001FFF0001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1478511\n"); + end + x = 64'h3EF0004000040000; + y = 64'h3FE0000000000000; + z = 64'h3FCFFFFFFFEFFFFF; + ans = 64'h3FD0002000780008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1479125\n"); + end + x = 64'h3FF0000000000001; + y = 64'hBFC000000007FFF7; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400EFFFFFFFF7FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1479739\n"); + end + x = 64'h151288F63CC0F407; + y = 64'hC3A078EE7C1CA23C; + z = 64'h37E0000400000FFF; + ans = 64'h37E0000400000FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1480353\n"); + end + x = 64'h3FF0000000000001; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01BFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1480967\n"); + end + x = 64'h7FF00000F8000000; + y = 64'hC3E00FFFFFFFFFFF; + z = 64'hBFD0000000000000; + ans = 64'h7FF80000F8000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1481581\n"); + end + x = 64'h3FF0000000000001; + y = 64'h3FF0000000000000; + z = 64'hBFFFF7FFF7FFFFFF; + ans = 64'hBFEFEFFFEFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1482195\n"); + end + x = 64'h4390001001FFFFFF; + y = 64'h41F00000400003FF; + z = 64'h73614A879212B060; + ans = 64'h73614A879212B060; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1482809\n"); + end + x = 64'h21700040000001FF; + y = 64'h3FF0000000000001; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1483423\n"); + end + x = 64'h3FF0000000000001; + y = 64'h4F41C01D1EBD97EE; + z = 64'h4030AF30C9E22201; + ans = 64'h4F41C01D1EBD97EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1484037\n"); + end + x = 64'hB300000000000000; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC03FFE003FFFFFFF; + ans = 64'hC03FFE003FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1484651\n"); + end + x = 64'h3FF0000000000001; + y = 64'h081000003FFFFDFF; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1485265\n"); + end + x = 64'h422000040001FFFE; + y = 64'hC1D4CBE79C60598B; + z = 64'h068EEFFFFFFFFFFE; + ans = 64'hC404CBECCF5CDA1D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1485879\n"); + end + x = 64'h3FF0000000000001; + y = 64'h4000000000000001; + z = 64'hC010000000000000; + ans = 64'hBFFFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1486493\n"); + end + x = 64'h0020000000BFFFFF; + y = 64'hC008D81E79C4BDF1; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1487107\n"); + end + x = 64'h3FF0000000000001; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hC80C000000003FFF; + ans = 64'hC80C000000003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1487721\n"); + end + x = 64'h402000001FFFFFFB; + y = 64'hBFD00003FFDFFFFF; + z = 64'hBFFFFFFC00000010; + ans = 64'hC01000010FF00401; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1488335\n"); + end + x = 64'h3F9FFFFFC00FFFFF; + y = 64'h4010000000000000; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1488949\n"); + end + x = 64'h3FF0000000000001; + y = 64'h12E0002000000000; + z = 64'h438FBFFFFFFEFFFF; + ans = 64'h438FBFFFFFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1489563\n"); + end + x = 64'h434FF80001FFFFFF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h2FEFFFFBF7FFFFFF; + ans = 64'h437FF80001FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1490177\n"); + end + x = 64'h3FF0000000000001; + y = 64'h93120000003FFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1490791\n"); + end + x = 64'hB7EFFFFFFFFFFFF1; + y = 64'hC1C946962E1C5437; + z = 64'hB3BF8000007FFFFF; + ans = 64'h39C946962E1C542B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1491405\n"); + end + x = 64'h3FF0000000000001; + y = 64'h4340000000000000; + z = 64'hC000000000000001; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1492019\n"); + end + x = 64'hC05FFFFFFE0001FE; + y = 64'hC033FB5821777B64; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h40A3FB582037C720; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1492633\n"); + end + x = 64'h3FF0000000000001; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hFFDFFFFFA0000000; + ans = 64'hFFDFFFFFA0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1493247\n"); + end + x = 64'hBFE0000082000000; + y = 64'h3F00000000000010; + z = 64'h3FEE3E1841C696F0; + ans = 64'h3FEE3DF841C592F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1493861\n"); + end + x = 64'hBFE0000100FFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC3580000807FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1494475\n"); + end + x = 64'h3FF0000000000001; + y = 64'hC0096863BF8D68B1; + z = 64'h8D53FFFFFFFF7FFF; + ans = 64'hC0096863BF8D68B3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1495089\n"); + end + x = 64'h4130FFFFFFFFFFF8; + y = 64'h7FE0000000000001; + z = 64'h400757A0F4028052; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1495703\n"); + end + x = 64'h3FF0000000000001; + y = 64'hFFE598A2EFE0CC56; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'hFFE598A2EFE0CC57; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1496317\n"); + end + x = 64'hBF8FFFFF0000FFFF; + y = 64'hCAAFFFFFFFFDEFFE; + z = 64'hBFB6E9A88034930A; + ans = 64'h4A4FFFFEFFFEEFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1496931\n"); + end + x = 64'h3FF0000000000001; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1497545\n"); + end + x = 64'h43D0000000087FFF; + y = 64'hD7B36A7D8CEAEBE7; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hDB936A7D8CF53C78; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1498159\n"); + end + x = 64'h3FF0000000000001; + y = 64'h7FF0000000000001; + z = 64'hBCA0007FFFFFFFEF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1498773\n"); + end + x = 64'hC03FFF000000000F; + y = 64'h403FFFF8000003FF; + z = 64'h37F00800003FFFFF; + ans = 64'hC08FFEF80040040E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1499387\n"); + end + x = 64'h4030000000FFBFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1500001\n"); + end + x = 64'h3FF0000000000001; + y = 64'h403FFFF0000000FF; + z = 64'hD4F00013FFFFFFFF; + ans = 64'hD4F00013FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1500615\n"); + end + x = 64'hC6DA302F95D53E41; + y = 64'h8000000000000000; + z = 64'h3A8FF7FFFE000000; + ans = 64'h3A8FF7FFFE000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1501229\n"); + end + x = 64'h3FF0000000000001; + y = 64'hBCA7FFFFFEFFFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1501843\n"); + end + x = 64'h3FBFFFFFFDFF7FFE; + y = 64'hC7EFFFFE00020000; + z = 64'h43AFFFFF8003FFFE; + ans = 64'hC7BFFFFDFE01801E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1502457\n"); + end + x = 64'h3FF0000000000001; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1503071\n"); + end + x = 64'h0003476357EBF517; + y = 64'h7FE000004000003F; + z = 64'h8000000000000000; + ans = 64'h3FDA3B1B284C141D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1503685\n"); + end + x = 64'h3FF0000000000001; + y = 64'h8010000000000000; + z = 64'hFFF71E22014210B7; + ans = 64'hFFFF1E22014210B7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1504299\n"); + end + x = 64'hB7F00000FFFFFFBF; + y = 64'hB81E94EC16510659; + z = 64'hE5900000000000FC; + ans = 64'hE5900000000000FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1504913\n"); + end + x = 64'h255FC00010000000; + y = 64'h8010000000000001; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1505527\n"); + end + x = 64'h3FF0000000000001; + y = 64'hC7E00000FFFFDFFF; + z = 64'hBFCDFFFC00000000; + ans = 64'hC7E00000FFFFE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1506141\n"); + end + x = 64'h381FEFFDFFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hFFF0207FFFFFFFFF; + ans = 64'hFFF8207FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1506755\n"); + end + x = 64'h3FF0000000000001; + y = 64'h406333A1C67874F2; + z = 64'h3FD0000000000000; + ans = 64'h40633BA1C67874F3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1507369\n"); + end + x = 64'h3F8000003FFBFFFF; + y = 64'hB3FFF8003FFFFFFF; + z = 64'h3CA5CDFC371469D5; + ans = 64'h3CA5CDFC371469D5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1507983\n"); + end + x = 64'h3FF0000000000001; + y = 64'hBCA0000000000001; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1508597\n"); + end + x = 64'hC011000400000000; + y = 64'hC1FEEDF467BB14D3; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1509211\n"); + end + x = 64'h3FF0000000000001; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hB9706068EB130215; + ans = 64'hBCB0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1509825\n"); + end + x = 64'h340FFFFFFFFFFFDC; + y = 64'hC3D8682AE89D9DE3; + z = 64'hB80FFE0000010000; + ans = 64'hB816190ABA27E772; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1510439\n"); + end + x = 64'h3BAFFFFFFFFFFF02; + y = 64'hBFD0000000000000; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1511053\n"); + end + x = 64'h3FF0000000000001; + y = 64'h002FF80008000000; + z = 64'h42EFEFFFFFEFFFFF; + ans = 64'h42EFEFFFFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1511667\n"); + end + x = 64'h388FFF7FFFFFDFFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h63CFFFEBFFFFFFFF; + ans = 64'h63CFFFEBFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1512281\n"); + end + x = 64'h3FF0000000000001; + y = 64'h480008000000000F; + z = 64'h3CA0000000000001; + ans = 64'h4800080000000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1512895\n"); + end + x = 64'hC04000001001FFFE; + y = 64'h3FD00E1A7AB10717; + z = 64'hBE9CEA205823E383; + ans = 64'hC0200E1A9936337F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1513509\n"); + end + x = 64'h3FF0000000000001; + y = 64'hBFE0000000000000; + z = 64'hBFD0000000000001; + ans = 64'hBFE8000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1514123\n"); + end + x = 64'h3E8FFFFF7FFFFDFF; + y = 64'hB80FFFFEFFFBFFFE; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1514737\n"); + end + x = 64'h3FF0000000000001; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h7FD0001FFFFFC000; + ans = 64'h7FD0001FFFFFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1515351\n"); + end + x = 64'h43DFFFFFFFFFBFEF; + y = 64'hC0100000BFFFFFFF; + z = 64'hBCA00FFF7FFFFFFF; + ans = 64'hC4000000BFFFDFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1515965\n"); + end + x = 64'h3DBF001FFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hC00000000000F800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1516579\n"); + end + x = 64'h3FF0000000000001; + y = 64'hBFCFF7FFFDFFFFFF; + z = 64'hBFE000000007FFFB; + ans = 64'hBFE7FDFFFF87FFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1517193\n"); + end + x = 64'h43E0001000001000; + y = 64'hBFF0000000000001; + z = 64'hC0F092135375188F; + ans = 64'hC3E0001000001022; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1517807\n"); + end + x = 64'h3FF0000000000001; + y = 64'hB81F7FFFFFFFFFBE; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hB81F7FFFFFFFFFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1518421\n"); + end + x = 64'hBF20000000003FEF; + y = 64'hA550A89F56EB2FAD; + z = 64'hC00003FFF7FFFFFF; + ans = 64'hC00003FFF7FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1519035\n"); + end + x = 64'h3FF0000000000001; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1519649\n"); + end + x = 64'h3FDFBFFFFFFFFDFF; + y = 64'hBFC0000000005FFE; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1520263\n"); + end + x = 64'h3FF0000000000001; + y = 64'hC000000000000001; + z = 64'h41BFFFE001FFFFFF; + ans = 64'h41BFFFDFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1520877\n"); + end + x = 64'hC3FFC003FFFFFFFF; + y = 64'h802F6AF6024C08B5; + z = 64'h3FEFFFFFF80FFFFE; + ans = 64'h3FEFFFFFF80FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1521491\n"); + end + x = 64'h4770000000017FFE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hC790000000017FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1522105\n"); + end + x = 64'h3FF0000000000001; + y = 64'hBFD40001FFFFFFFE; + z = 64'hC04007FFFFFFFBFF; + ans = 64'hC040300003FFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1522719\n"); + end + x = 64'h41D566DE1FA9698E; + y = 64'hC010000000000000; + z = 64'h3FC01FFFFFFDFFFE; + ans = 64'hC1F566DE1FA7658E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1523333\n"); + end + x = 64'h3FF0000000000001; + y = 64'h47F4831548A0898D; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h47F4831548A0898E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1523947\n"); + end + x = 64'h434000000021FFFF; + y = 64'hC1CFFFFFFFFF7FF7; + z = 64'h37F0080080000000; + ans = 64'hC52000000021BFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1524561\n"); + end + x = 64'h3FF0000000000001; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hC020000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1525175\n"); + end + x = 64'h7E6FFFF80000007F; + y = 64'h37E0008FFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h7660008BFFDC003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1525789\n"); + end + x = 64'h3FF0000000000001; + y = 64'hC340000000000000; + z = 64'hC770000000023FFF; + ans = 64'hC770000000023FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1526403\n"); + end + x = 64'hE9500000001FFFFF; + y = 64'hC00BFFFFF7FFFFFF; + z = 64'h2EDBFFFFFFFC0000; + ans = 64'h696BFFFFF837FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1527017\n"); + end + x = 64'h47F000003FFFFFE0; + y = 64'hC340000000000001; + z = 64'hBFE0000000000000; + ans = 64'hCB4000003FFFFFE1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1527631\n"); + end + x = 64'h3FF0000000000001; + y = 64'hAA790F9E140279B6; + z = 64'h3FE08000000FFFFF; + ans = 64'h3FE08000000FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1528245\n"); + end + x = 64'hC0A007FFFEFFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hB810000004000003; + ans = 64'h440007FFFEFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1528859\n"); + end + x = 64'h3FF0000000000001; + y = 64'h3FC7F50DD5148BA7; + z = 64'h0000000000000000; + ans = 64'h3FC7F50DD5148BA8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1529473\n"); + end + x = 64'h4698040000000000; + y = 64'h37FFEFFFFFFFBFFF; + z = 64'h200000FBFFFFFFFF; + ans = 64'h3EA7F7FDFFFFCFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1530087\n"); + end + x = 64'h3FF0000000000001; + y = 64'hFFE0000000000001; + z = 64'h8010000000000000; + ans = 64'hFFE0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1530701\n"); + end + x = 64'h790000100000001F; + y = 64'hC2D58B4193E58B37; + z = 64'h4010000000000001; + ans = 64'hFBE58B571F271F46; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1531315\n"); + end + x = 64'h3FF0000000000001; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h40769FBEEA3D4736; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1531929\n"); + end + x = 64'hC3E0007FFFFFFFFF; + y = 64'hC0000000000207FF; + z = 64'hFFD000000001EFFF; + ans = 64'hFFD000000001EFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1532543\n"); + end + x = 64'h3FD3EEE5BED7AEF6; + y = 64'hFFF0000000000000; + z = 64'hBFD0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1533157\n"); + end + x = 64'h3FF0000000000001; + y = 64'h43EF800400000000; + z = 64'hC02FFFFFFFFFFF40; + ans = 64'h43EF800400000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1533771\n"); + end + x = 64'hAF94000000003FFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h37F000001EFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1534385\n"); + end + x = 64'h3FF0000000000001; + y = 64'hB9FF00000003FFFF; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1534999\n"); + end + x = 64'hC34439AD7B57B86A; + y = 64'h41CFFFFFFFF807FE; + z = 64'h429FFDFFFFFFF000; + ans = 64'hC52439AD7B529F0D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1535613\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h0000000000000000; + z = 64'h8000000000000001; + ans = 64'h8000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1536227\n"); + end + x = 64'hC02BBD44DD056675; + y = 64'hC1C000000005FFFF; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h41FBBD44DD4FCD6D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1536841\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3FBFFFE001FFFFFF; + ans = 64'h3FBFFFE001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1537455\n"); + end + x = 64'h3CAFFFFFFF83FFFF; + y = 64'h37E00003FFFFFFDE; + z = 64'h40200000003FFFF7; + ans = 64'h40200000003FFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1538069\n"); + end + x = 64'h3F1000047FFFFFFE; + y = 64'h000FFFFFFFFFFFFE; z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; @@ -35146,12 +117819,3020 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1504457\n"); + $fwrite(fp,"1538683\n"); end - x = 64'hD32DFFFFFFFFFFFF; + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h43F2459EC8CC5AA8; + z = 64'hBFBC00D7CE203DB4; + ans = 64'h4402459EC8CC5AA7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1539297\n"); + end + x = 64'h380FFFFFFF7FF7FE; + y = 64'h0010000000000001; + z = 64'hFFEFFFFFFFFFF80F; + ans = 64'hFFEFFFFFFFFFF80F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1539911\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h43C010001FFFFFFF; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1540525\n"); + end + x = 64'h41D00FFFFFFFFFFB; + y = 64'hA8FC400000000000; + z = 64'h4051000000001FFF; + ans = 64'h4051000000001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1541139\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1541753\n"); + end + x = 64'h454000000000FF7E; + y = 64'hC3CFFFFDFFFFFF80; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'hC91FFFFE0001FE7C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1542367\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3CA0000000000001; + z = 64'h98800000400000FF; + ans = 64'h3CB0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1542981\n"); + end + x = 64'hD90077FFFFFFFFFF; + y = 64'h41CFFFFFFFFFFFFF; + z = 64'h3FEFFFFFFFFF7FFD; + ans = 64'hDAE077FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1543595\n"); + end + x = 64'h37FFFFFC000007FF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h34BFFFFC000007FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1544209\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hFFAFFFFFFFBFFDFE; + z = 64'h3FE2863660754A51; + ans = 64'hFFBFFFFFFFBFFDFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1544823\n"); + end + x = 64'hB8100000FFFFFDFE; + y = 64'h3FD0000000000000; + z = 64'h41C0000800000000; + ans = 64'h41C0000800000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1545437\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h366FFFFE00400000; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1546051\n"); + end + x = 64'hA18FDD1E4F1D8794; + y = 64'hE5FE3FFFFFFFFFFF; + z = 64'hC1EC6D016FC1B191; + ans = 64'h479E1F06A6C9EA29; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1546665\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1547279\n"); + end + x = 64'h3FCFFFF1FFFFFFFF; + y = 64'hB8000001FF7FFFFF; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1547893\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3FE0000000000000; + z = 64'h0011BC66A6AFD091; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1548507\n"); + end + x = 64'h68A5BD6C73D63CB8; + y = 64'h43D1FFF7FFFFFFFF; + z = 64'h3C40008000FFFFFF; + ans = 64'h6C88750F239ACA63; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1549121\n"); + end + x = 64'h3CAFFFFFC0000003; + y = 64'h3FE0000000000001; + z = 64'h8010000000000000; + ans = 64'h3C9FFFFFC0000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1549735\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3F6000023FFFFFFE; + z = 64'h7FF00001FFFEFFFE; + ans = 64'h7FF80001FFFEFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1550349\n"); + end + x = 64'hBF000000007FE000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hBFDFFFFFF5FFFFFF; + ans = 64'hBFE0003FFB0001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1550963\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hB361F0FC60A5C255; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1551577\n"); + end + x = 64'hC0300000002FFFFE; + y = 64'h395FFFEFFFFFFFFF; + z = 64'hB95FFFEFFFF7FFFF; + ans = 64'hB9A0FFF7802FBFE5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1552191\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3FF0000000000001; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1552805\n"); + end + x = 64'hA140000000FFFFBE; + y = 64'h40BFFFFF00000007; + z = 64'h3FE0000000000001; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1553419\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h496131E708AD247B; + ans = 64'h496131E708AD247B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1554033\n"); + end + x = 64'h40233C8AC990330C; + y = 64'h3E6000000003DFFF; + z = 64'h3FD0007FF7FFFFFF; + ans = 64'h3FD000812BC8AC98; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1554647\n"); + end + x = 64'hBDD00000000FFFDF; + y = 64'h4000000000000000; + z = 64'h8000000000000001; + ans = 64'hBDE00000000FFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1555261\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h7FEB41A3838A8AC9; + z = 64'hCBDFFFFFFFD7FFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1555875\n"); + end + x = 64'hBE8C8E5F27717F72; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h409000000000FFFC; + ans = 64'h408FFFFFFF8FC67B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1556489\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3F3FFFFFFEFFFFFF; + z = 64'hC010000000000001; + ans = 64'hC00FFE0000001002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1557103\n"); + end + x = 64'h7FF8F9996F21B694; + y = 64'hB14FFFFFFFFC001F; + z = 64'hD36000000BFFFFFF; + ans = 64'h7FF8F9996F21B694; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1557717\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h4010000000000000; + z = 64'h4340000000000001; + ans = 64'h4340000000000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1558331\n"); + end + x = 64'hFFDFFFE01FFFFFFE; + y = 64'h400FFFF3FFFFFFFF; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1558945\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h4010000000000001; + z = 64'hC1D3347EDAE48B72; + ans = 64'hC1D3347ED8E48B72; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1559559\n"); + end + x = 64'h000ACDCC076E0ADF; + y = 64'h3D6666AA8E1AABE5; + z = 64'h403BFFFFFFF7FFFF; + ans = 64'h403BFFFFFFF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1560173\n"); + end + x = 64'h381000000FFF0000; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1560787\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3CAF800001FFFFFE; + z = 64'h3800000002100000; + ans = 64'h3CBF800001FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1561401\n"); + end + x = 64'hC3EFFFFFDFFFFFFA; + y = 64'h4340000000000001; + z = 64'hC680063611833898; + ans = 64'hC740010053611832; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1562015\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hAE79CAC1FE3DF21C; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1562629\n"); + end + x = 64'h35200007FFFFE000; + y = 64'hBFBFFFFFFDEFFFFF; + z = 64'hBFF6AC5CC5343BAF; + ans = 64'hBFF6AC5CC5343BAF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1563243\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h435FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1563857\n"); + end + x = 64'h3FC00FFFFFFFFF7E; + y = 64'hB80000000080003F; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1564471\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'h9520000001FFFBFE; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1565085\n"); + end + x = 64'h3F2BFFFFFFFFFFFD; + y = 64'h80200FFFFFBFFFFE; + z = 64'hC1F0000003FBFFFE; + ans = 64'hC1F0000003FBFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1565699\n"); + end + x = 64'hEA600000001000FF; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1566313\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hC3FFFFFFFFFFF801; + z = 64'hFFF00000FFDFFFFE; + ans = 64'hFFF80000FFDFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1566927\n"); + end + x = 64'h37DFE000003FFFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hC04FFFFFFFFFB7FE; + ans = 64'h77DFE000003FFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1567541\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h400FFFE200000000; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'h4017FFE200000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1568155\n"); + end + x = 64'hBFCFFFFFFFFFF810; + y = 64'h3FF0000003FFBFFF; + z = 64'h41EFF8007FFFFFFF; + ans = 64'h41EFF8007FF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1568769\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1569383\n"); + end + x = 64'hBC3FFFFFFFFFFC01; + y = 64'hBFD0484EBF02F052; + z = 64'h3CA0000000000000; + ans = 64'h3CA010484EBF02EE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1569997\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h00000007FFC00000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1570611\n"); + end + x = 64'h43FFFFFFFFFFC001; + y = 64'h47FFB25D4AD4E4DB; + z = 64'h3FF0080000000000; + ans = 64'h4C0FB25D4AD4A577; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1571225\n"); + end + x = 64'h402F81736BA4D5A0; + y = 64'h8000000000000001; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1571839\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3FB4004000000000; + z = 64'h41631A545858549B; + ans = 64'h41631A545D58649B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1572453\n"); + end + x = 64'h41F7FFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h41C1C06162ADBF79; + ans = 64'h41C1C06162ADBF79; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1573067\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3FC00FFFFFFFFE00; + z = 64'hBFF0000000000000; + ans = 64'hBFE7F80000000100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1573681\n"); + end + x = 64'h000FFFFFFFFF8004; + y = 64'hBFCFFF8000000001; + z = 64'h3FF00000000004FF; + ans = 64'h3FF00000000004FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1574295\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h8010000000000001; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1574909\n"); + end + x = 64'h411FFFC000100000; + y = 64'hBC40004FFFFFFFFE; + z = 64'h0010000000000001; + ans = 64'hBD70002FFF680026; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1575523\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h3BE292DF5A68281D; + ans = 64'h3BE292DF5A68281D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1576137\n"); + end + x = 64'h3F60401000000000; + y = 64'h294000020000000F; + z = 64'h80000407FFFFFFFE; + ans = 64'h28B040120802000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1576751\n"); + end + x = 64'h4801FFFFFFFFFFFE; + y = 64'hBCA0000000000000; + z = 64'h4340000000000001; + ans = 64'hC4B1FFFFDFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1577365\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hC7E000001001FFFF; + z = 64'h309FFFFFFFBFFFF0; + ans = 64'hC7F000001001FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1577979\n"); + end + x = 64'hBE203FFFFFF00000; y = 64'hBCA0000000000001; - z = 64'hBFFDFFFFFDFFFFFE; - ans = 64'h4FDE000000000001; + z = 64'hC030000000003EFF; + ans = 64'hC030000000003EFF; rn = 1; rz = 0; rm = 0; @@ -35193,12 +120874,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1506471\n"); + $fwrite(fp,"1578593\n"); end - x = 64'h400FFBFFFFFFFFFE; - y = 64'h342FFFFFFF007FFF; - z = 64'h8A1FBFDFFFFFFFFF; - ans = 64'h344FFBFFFF009FED; + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hC1D0000040FFFFFE; + z = 64'hBFE0000000000001; + ans = 64'hC1E00000410FFFFD; rn = 1; rz = 0; rm = 0; @@ -35240,10 +120921,57 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1508485\n"); + $fwrite(fp,"1579207\n"); end - x = 64'h3FF0000000000001; - y = 64'hBFDFFFFFFFFFFFFF; + x = 64'h3A50400000080000; + y = 64'hC7EFFFFF6FFFFFFF; + z = 64'hA51FFFFFFFFF7000; + ans = 64'hC2503FFFB6E7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1579821\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hBFD0000000000000; z = 64'h3FF0000000000001; ans = 64'h3FE0000000000002; rn = 1; @@ -35287,12 +121015,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1510499\n"); + $fwrite(fp,"1580435\n"); end - x = 64'h9F17C42487B3329A; + x = 64'h8000408000000000; + y = 64'hB7F00001FFFFFE00; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h000FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1581049\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hBFD0000000000001; + z = 64'hC02000000080007E; + ans = 64'hC02100000080007E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1581663\n"); + end + x = 64'h3280000780000000; + y = 64'h7FD007DFFFFFFFFF; + z = 64'h4C8FFFEFDFFFFFFF; + ans = 64'h726007E783B0FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1582277\n"); + end + x = 64'hBEAFFFFFFFFFF007; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h402000000FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1582891\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h42DFFDFFFFFFFFFF; + z = 64'h3F4FFFFF3FFFFFFF; + ans = 64'h42EFFDFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1583505\n"); + end + x = 64'hBFBE000003FFFFFF; y = 64'hBFE0000000000000; - z = 64'h4800003FFFFFFFE0; - ans = 64'h4800003FFFFFFFE0; + z = 64'hAC9FEFFFFFFFFEFF; + ans = 64'h3FAE000003FFFFFF; rn = 1; rz = 0; rm = 0; @@ -35334,12 +121297,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1512513\n"); + $fwrite(fp,"1584119\n"); end - x = 64'hB09000002007FFFF; - y = 64'hC01B59E3519ADF64; - z = 64'h43C00000000007FD; - ans = 64'h43C00000000007FD; + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hC1D0000008000400; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hC1E00000081003FF; rn = 1; rz = 0; rm = 0; @@ -35381,12 +121344,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1514527\n"); + $fwrite(fp,"1584733\n"); end - x = 64'h3FF0000000000001; - y = 64'hBFF0000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000001; + x = 64'hD2B1000000007FFF; + y = 64'hCA8186CC19B70C07; + z = 64'hC00EB7E6E75515EB; + ans = 64'h5D429F38DB5308FD; rn = 1; rz = 0; rm = 0; @@ -35428,12 +121391,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1516541\n"); + $fwrite(fp,"1585347\n"); end - x = 64'hBFA0001000000000; - y = 64'hC000000000000000; - z = 64'h219FFFFFFFFFF810; - ans = 64'h3FB0001000000000; + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFB; rn = 1; rz = 0; rm = 0; @@ -35475,12 +121438,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1518555\n"); + $fwrite(fp,"1585961\n"); end - x = 64'h802000000FFFFFF7; - y = 64'hC34FFFFFFFFEFF7F; - z = 64'hC3DF01FFFFFFFFFE; - ans = 64'hC3DF01FFFFFFFFFE; + x = 64'hC0300BFFFFFFFFFE; + y = 64'h744003FFFFFFFFFC; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -35522,12 +121485,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1520569\n"); + $fwrite(fp,"1586575\n"); end - x = 64'h3FF0000000000001; - y = 64'hC010000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hBFF0000000000000; + z = 64'hB7F06F51947E5EFA; + ans = 64'hBFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -35569,12 +121532,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1522583\n"); + $fwrite(fp,"1587189\n"); end - x = 64'h41F03FFFBFFFFFFF; - y = 64'hC340000000000000; - z = 64'h5A2FFDFBFFFFFFFE; - ans = 64'h5A2FFDFBFFFFFFFE; + x = 64'hBCAFFFFFFDFEFFFF; + y = 64'hDBDFFFFFFFF5FFFE; + z = 64'h45465A4CBC45F897; + ans = 64'h589FFFFFFDF4FFFD; rn = 1; rz = 0; rm = 0; @@ -35616,12 +121579,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1524597\n"); + $fwrite(fp,"1587803\n"); end - x = 64'h4816468957EB0E3D; - y = 64'hBFFEA99B5235F21E; - z = 64'hBF1000010000FFFE; - ans = 64'hC825583166A83DE6; + x = 64'h4080000000007DFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'hC08FE0000000FBFB; rn = 1; rz = 0; rm = 0; @@ -35663,12 +121626,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1526611\n"); + $fwrite(fp,"1588417\n"); end - x = 64'h3FF0000000000001; - y = 64'hFFE0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFE0000000000002; + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3FD02003FFFFFFFF; + z = 64'hB80E4FB403E45282; + ans = 64'h3FE02003FFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -35710,11 +121673,199 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1528625\n"); + $fwrite(fp,"1589031\n"); end - x = 64'h73D00000001F8000; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'h3810800000000800; + x = 64'h4DC0007FFFFFBFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h7FF1C24919B8C488; + ans = 64'h7FF9C24919B8C488; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1589645\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hC06FFBFFFFFFFFDF; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hC07FFBFFFFFFFFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1590259\n"); + end + x = 64'h0C30001000001FFF; + y = 64'h3FDFFFFFFFFBFFFD; + z = 64'hC3E2000000003FFF; + ans = 64'hC3E2000000003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1590873\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'hC01DFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1591487\n"); + end + x = 64'h39A00000FFFFFFF7; + y = 64'hC0200000FFFFFFFF; + z = 64'hFFF0000000000000; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -35757,1375 +121908,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1530639\n"); - end - x = 64'hBF7107FFFFFFFFFF; - y = 64'h3FDEFFFFFFFFDFFF; - z = 64'hC02010000FFFFFFE; - ans = 64'hC02011080BFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1532653\n"); + $fwrite(fp,"1592101\n"); end x = 64'h3FFFFFFFFFFFFFFF; - y = 64'h0000000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1534667\n"); - end - x = 64'h3BEFE000000FFFFE; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hBFD602A609EE9BAB; - ans = 64'hBFD602A609EE9BAB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1536681\n"); - end - x = 64'hBFF000403FFFFFFF; - y = 64'h3FDF3E0BE31EBEE9; - z = 64'hB802C73B4852E1E1; - ans = 64'hBFDF3E8958467AEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1538695\n"); - end - x = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3CA0000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1540709\n"); - end - x = 64'h3FC0FFFFFFFFFFF7; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'hBF8011FFFFFFFFFF; - ans = 64'hBF8011FFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1542723\n"); - end - x = 64'h37FFFFFF00000006; - y = 64'hC7E00001FFFFFFDE; - z = 64'h41C795C3980A9C95; - ans = 64'h41C795C3978A9C89; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1544737\n"); - end - x = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1546751\n"); - end - x = 64'h402FFFFDEFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h43D1A195ABB1C5B6; - ans = 64'h43D1A195ABB1C5B6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1548765\n"); - end - x = 64'h44EFFBDFFFFFFFFF; - y = 64'h321FFFFFFFFF00FF; - z = 64'h1042F2308B3C2796; - ans = 64'h371FFBDFFFFF011F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1550779\n"); - end - x = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1552793\n"); - end - x = 64'h41FFFFF7FFBFFFFE; - y = 64'h400FFFFFFFFFFFFF; - z = 64'hBF59AF9A3B538749; - ans = 64'h421FFFF7FFBFFE62; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1554807\n"); - end - x = 64'h4E5F3DCE4E5C17A8; - y = 64'hAEEA7C211E03A2CE; - z = 64'hC00001EFFFFFFFFE; - ans = 64'hC00001F000000339; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1556821\n"); - end - x = 64'h3FFFFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h4030FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1558835\n"); - end - x = 64'h8DDFFFF7FFFFFF7E; - y = 64'h4340000000000001; - z = 64'h352C9FA3227CAA38; - ans = 64'h352C9FA3227CAA38; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1560849\n"); - end - x = 64'h2080001000FFFFFF; - y = 64'hC1C000800001FFFE; - z = 64'hC1F4007FFFFFFFFE; - ans = 64'hC1F4007FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1562863\n"); - end - x = 64'h3FFFFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1564877\n"); - end - x = 64'h480FF84D125A7C3B; - y = 64'h7FF0000000000001; - z = 64'h43EBFFFFFFFFFF7F; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1566891\n"); - end - x = 64'hBEBFFFFFFFFFFFFF; - y = 64'h3CA000007FEFFFFE; - z = 64'hC7CF6EC72066389A; - ans = 64'hC7CF6EC72066389A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1568905\n"); - end - x = 64'h3FFFFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1570919\n"); - end - x = 64'h43CD3C8F860948FC; - y = 64'h8010000000000001; - z = 64'hBCAFF7FFFFFFF000; - ans = 64'hBCAFF7FFFFFFF000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1572933\n"); - end - x = 64'hC1FFC4B612DC685B; - y = 64'h37EECB94D4DFCE99; - z = 64'h6C10000002001FFE; - ans = 64'h6C10000002001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1574947\n"); - end - x = 64'h3FFFFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1576961\n"); - end - x = 64'h4C500FFF00000000; - y = 64'hBFD0000000000000; - z = 64'h403FFFFFFFFFFFFF; - ans = 64'hCC300FFF00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1578975\n"); - end - x = 64'hBFF000000020007F; - y = 64'hC1E00001FFFFFFDE; - z = 64'hBE80003FFFFFFFFD; - ans = 64'h41E0000200200061; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1580989\n"); - end - x = 64'h3FFFFFFFFFFFFFFF; - y = 64'hBFE0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1583003\n"); - end - x = 64'h3FDFFFFFFFFFDFF7; - y = 64'hBFF0000000000000; - z = 64'hBFB503DCF633DA77; - ans = 64'hBFE2A07B9EC66B4A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1585017\n"); - end - x = 64'hC7EFFFFF7FFFFFF8; - y = 64'h362AE3F6FB550D7A; - z = 64'hC3D87959643FFA05; - ans = 64'hC3D87959643FFA05; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1587031\n"); - end - x = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC000000000000001; - z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1589045\n"); - end - x = 64'h47F0000003FFBFFE; y = 64'hC00FFFFFFFFFFFFE; - z = 64'hB7E040001FFFFFFE; - ans = 64'hC810000003FFBFFD; + z = 64'hC2AA4072EAF00758; + ans = 64'hC2AA4072EAF01758; rn = 1; rz = 0; rm = 0; @@ -37167,12 +121955,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1591059\n"); + $fwrite(fp,"1592715\n"); end - x = 64'hC1ED0FDDB8CC4595; - y = 64'hC02000003FFFFBFF; - z = 64'hB8025D3A7A488076; - ans = 64'h421D0FDE2D0BB532; + x = 64'h37FD755CDABEA76D; + y = 64'h3C5FFFDBFFFFFFFF; + z = 64'hBFE0000000007FF8; + ans = 64'hBFE0000000007FF8; rn = 1; rz = 0; rm = 0; @@ -37214,12 +122002,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1593073\n"); + $fwrite(fp,"1593329\n"); + end + x = 64'h801197F207B69AE6; + y = 64'hC010000000000001; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1593943\n"); end x = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC340000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + y = 64'h41EF00000000001F; + z = 64'h315FFFFFFFFFFFC0; + ans = 64'h41FF00000000001E; rn = 1; rz = 0; rm = 0; @@ -37261,12 +122096,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1595087\n"); + $fwrite(fp,"1594557\n"); end - x = 64'h495003D31DDD9B75; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h480956CD1FF74A85; - ans = 64'hCCB003D31DDD9B74; + x = 64'hABBFFBFFFFFF0000; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hC1F748C9C20C8D0E; + ans = 64'hC1F748C9C20C8D0E; rn = 1; rz = 0; rm = 0; @@ -37308,12 +122143,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1597101\n"); + $fwrite(fp,"1595171\n"); end - x = 64'h3FCFFFFFBFFFFFFC; - y = 64'h86F0000083FFFFFF; - z = 64'hD1D00000000FFF7F; - ans = 64'hD1D00000000FFF7F; + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h480FFFFFFFFFC07F; + z = 64'hBCA0000000000000; + ans = 64'h481FFFFFFFFFC07E; rn = 1; rz = 0; rm = 0; @@ -37355,11 +122190,481 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1599115\n"); + $fwrite(fp,"1595785\n"); + end + x = 64'h3FF0000000007FDF; + y = 64'h6E3FFFFFDFFFFFDF; + z = 64'h7FF1FEFFFFFFFFFF; + ans = 64'h7FF9FEFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1596399\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hC340000000000001; + z = 64'h3FD0000000000000; + ans = 64'hC350000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1597013\n"); + end + x = 64'hB800005FFFFFFFFF; + y = 64'hC18FFFFFFE0007FE; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1597627\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h3FE8DD2068625FC3; + ans = 64'hC35FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1598241\n"); + end + x = 64'hC035303BE73A8A2A; + y = 64'hB7FFFFFFDFFFBFFF; + z = 64'h43A6B1CE510FDDF7; + ans = 64'h43A6B1CE510FDDF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1598855\n"); + end + x = 64'hB21FFFFE0001FFFE; + y = 64'hFFE0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h720FFFFE0001FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1599469\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hBFF00000000BFFFF; + z = 64'hBE90000000203FFE; + ans = 64'hC0000000200BFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1600083\n"); + end + x = 64'h43F0000EFFFFFFFF; + y = 64'hFFE0000000000001; + z = 64'h00218A882612E878; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1600697\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3F90000000083FFF; + z = 64'h8010000000000001; + ans = 64'h3FA0000000083FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1601311\n"); + end + x = 64'h49EE00FFFFFFFFFE; + y = 64'h60BFFFF7FFF00000; + z = 64'h401FFE0000000002; + ans = 64'h6ABE00F87FB0FF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1601925\n"); end x = 64'h3FFFFFFFFFFFFFFF; y = 64'hFFF0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3CA0000000000001; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -37402,11 +122707,152 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1601129\n"); + $fwrite(fp,"1602539\n"); end - x = 64'h3C409FFFFFFFFFFE; + x = 64'h3FF0001FFFFFFFFF; + y = 64'h37F1095A919815A3; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1603153\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hFFF0000000000001; + z = 64'hD282D5D3556E116C; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1603767\n"); + end + x = 64'h802FFFFFFFF001FF; + y = 64'h3F4FBFFFFFFFFFDF; + z = 64'hB81BE0B691B01D79; + ans = 64'hB81BE0B691B01D79; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1604381\n"); + end + x = 64'h41D0040000000000; y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hC0700200FFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFF; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -37449,12 +122895,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1603143\n"); + $fwrite(fp,"1604995\n"); end - x = 64'hC2700007FFFFFFF8; - y = 64'h3FD0000041FFFFFE; - z = 64'h5EE41DC74D68BD8D; - ans = 64'h5EE41DC74D68BD8D; + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hBC8FFF7FFFFFFFFF; + z = 64'h802C00000000007E; + ans = 64'hBC9FFF7FFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -37496,12 +122942,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1605157\n"); + $fwrite(fp,"1605609\n"); + end + x = 64'hB71A7857DD67746E; + y = 64'h0000000000000000; + z = 64'h380007F7FFFFFFFF; + ans = 64'h380007F7FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1606223\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h40541CECECF3BC00; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h40641CECECF3BBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1606837\n"); + end + x = 64'h0DFFFFFF00000008; + y = 64'hC7E000000008001F; + z = 64'h7FF6A62452074BC7; + ans = 64'h7FFEA62452074BC7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1607451\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h002FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1608065\n"); + end + x = 64'h800FFFF7FFFFBFFF; + y = 64'h407335261EC0BFB2; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1608679\n"); end x = 64'h3FFFFFFFFFFFFFFE; y = 64'h0010000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; + z = 64'hD0B01FFFFFFFBFFF; + ans = 64'hD0B01FFFFFFFBFFF; rn = 1; rz = 0; rm = 0; @@ -37543,12 +123224,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1607171\n"); + $fwrite(fp,"1609293\n"); end - x = 64'hBFE00FEFFFFFFFFF; + x = 64'hBFDFFFC000000004; + y = 64'hC00000000003FFBF; + z = 64'hC53BFBFFFFFFFFFE; + ans = 64'hC53BFBFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1609907\n"); + end + x = 64'h43C483F6E8D46B6A; y = 64'h001FFFFFFFFFFFFF; - z = 64'hC0200000021FFFFE; - ans = 64'hC0200000021FFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -37590,59 +123318,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1609185\n"); - end - x = 64'hC00F800000002000; - y = 64'h3FC7FFFBFFFFFFFF; - z = 64'hC6EFFE0000800000; - ans = 64'hC6EFFE0000800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1611199\n"); + $fwrite(fp,"1610521\n"); end x = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + y = 64'hC3EFFFFE01FFFFFE; + z = 64'h40F73755595D1E7C; + ans = 64'hC3FFFFFE01FFFFE5; rn = 1; rz = 0; rm = 0; @@ -37684,12 +123365,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1613213\n"); + $fwrite(fp,"1611135\n"); end - x = 64'h0007FFFFFFFBFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h3FB0000008000000; - ans = 64'h3FB0000008000000; + x = 64'h410FFFFF8000001E; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hC1FD1E0EB5DF203D; + ans = 64'hC1FD1E0EB5DF203D; rn = 1; rz = 0; rm = 0; @@ -37731,57 +123412,10 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1615227\n"); - end - x = 64'hD329292015820F2A; - y = 64'hC03FFFFFFFFFFBEF; - z = 64'h40557E8B8D949070; - ans = 64'h5379292015820BF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1617241\n"); + $fwrite(fp,"1611749\n"); end x = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFE; + y = 64'hFFD53A3B1BD0418E; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -37825,12 +123459,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1619255\n"); + $fwrite(fp,"1612363\n"); end - x = 64'hBFB0200001000000; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h3EC000000007FFF7; - ans = 64'hBFC01FF000FFFFF7; + x = 64'hC00FFFEFFFFFF7FE; + y = 64'hC3CFE001FFFFFFFE; + z = 64'h41C00003FFFFFF7F; + ans = 64'h43EFDFF21002F805; rn = 1; rz = 0; rm = 0; @@ -37872,59 +123506,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1621269\n"); - end - x = 64'hC3E76F2C56D0D8D0; - y = 64'hC04FC00000000020; - z = 64'h42EF800000000007; - ans = 64'h4447404E7C233736; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1623283\n"); + $fwrite(fp,"1612977\n"); end x = 64'h3FFFFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFC; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h3CBFFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -37966,12 +123553,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1625297\n"); + $fwrite(fp,"1613591\n"); end - x = 64'h401FFFFFDEFFFFFF; - y = 64'h4010000000000001; - z = 64'h3FDC00000FFFFFFF; - ans = 64'h404037FFEFA00000; + x = 64'h3FC0400040000000; + y = 64'hC0200000004001FE; + z = 64'hC010000000000000; + ans = 64'hC014100010104082; rn = 1; rz = 0; rm = 0; @@ -38013,59 +123600,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1627311\n"); - end - x = 64'hC0BFFFFFFFFFFDC0; - y = 64'h4E3FFFFBFBFFFFFF; - z = 64'hBFC0000081000000; - ans = 64'hCF0FFFFBFBFFFDBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1629325\n"); + $fwrite(fp,"1614205\n"); end x = 64'h3FFFFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'h435FFFFFFFFFFFFD; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h47EEC35A3E8C408E; + ans = 64'h47EEC35A3E8C408E; rn = 1; rz = 0; rm = 0; @@ -38107,11 +123647,199 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1631339\n"); + $fwrite(fp,"1614819\n"); end - x = 64'h43423BCFF86BBAE2; - y = 64'h7FE0000000000001; - z = 64'h7FE4C40B5E3A4BEC; + x = 64'hB7CFFFFDFFFFFFBE; + y = 64'hE79FFFFFFBFFFF7E; + z = 64'hB7FFFFE000000400; + ans = 64'h5F7FFFFDFBFFFF7C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1615433\n"); + end + x = 64'h3D5DFFFE00000000; + y = 64'h3FD0000000000001; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000780; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1616047\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hC12FFEFFFFFFFFFE; + z = 64'hBFDC4312AA3B4103; + ans = 64'hC13FFF00710C4AA5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1616661\n"); + end + x = 64'h4020000000000207; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3CB10000000003FE; + ans = 64'h4010000000000207; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1617275\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hB7E00000000007BF; + z = 64'h7FF0000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -38154,12 +123882,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1633353\n"); + $fwrite(fp,"1617889\n"); end - x = 64'hBCA0000DFFFFFFFF; - y = 64'hB8500000000FFFEE; - z = 64'h36C9B3089EDD6940; - ans = 64'h36C9B3089FDD6A20; + x = 64'h43CFFFFEFFFFFE00; + y = 64'hC3E1DFFFFFFFFFFE; + z = 64'hC3DFDB4465B607F2; + ans = 64'hC7C1DFFF70FFFEE0; rn = 1; rz = 0; rm = 0; @@ -38201,12 +123929,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1635367\n"); + $fwrite(fp,"1618503\n"); end x = 64'h3FFFFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3FE0000000000001; + z = 64'h0000000000000000; + ans = 64'h3FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -38248,12 +123976,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1637381\n"); + $fwrite(fp,"1619117\n"); end - x = 64'hC3CFFFDFFFE00000; - y = 64'h8000000000000000; - z = 64'hC1C001FFFDFFFFFF; - ans = 64'hC1C001FFFDFFFFFF; + x = 64'h43401FFFFFFFFFBF; + y = 64'hBFCFFBFFFFFFFE00; + z = 64'hC000000000000001; + ans = 64'hC3201DFBFFFFFEC1; rn = 1; rz = 0; rm = 0; @@ -38295,59 +124023,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1639395\n"); - end - x = 64'h456000020007FFFE; - y = 64'h401BE502A9566269; - z = 64'hC23D72CB92AE4C26; - ans = 64'h458BE5062604AA11; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1641409\n"); + $fwrite(fp,"1619731\n"); end x = 64'h3FFFFFFFFFFFFFFE; - y = 64'h8010000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h41D0B0544FEB5078; + ans = 64'h41D0B054506B5078; rn = 1; rz = 0; rm = 0; @@ -38389,12 +124070,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1643423\n"); + $fwrite(fp,"1620345\n"); end - x = 64'h3ECFFFDFFFFEFFFE; - y = 64'hBCA0000000000000; - z = 64'h0CCFFFFF00000006; - ans = 64'hBB7FFFDFFFFEFFFE; + x = 64'h434FFFFFFFF8FFFF; + y = 64'h400FFFFC07FFFFFE; + z = 64'hC3D07FFFFBFFFFFF; + ans = 64'hC3D0400003F00DFF; rn = 1; rz = 0; rm = 0; @@ -38436,12 +124117,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1645437\n"); + $fwrite(fp,"1620959\n"); end - x = 64'h43EFFFEFFFFFFF7F; - y = 64'hC020001FFFFFE000; - z = 64'h4039E58242A7C1BA; - ans = 64'hC4200017FFEFDFC0; + x = 64'hB7F0003FFFFFFFBF; + y = 64'h3FF0000000000000; + z = 64'h3CA0000000000001; + ans = 64'h3CA0000000000001; rn = 1; rz = 0; rm = 0; @@ -38483,12 +124164,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1647451\n"); + $fwrite(fp,"1621573\n"); end x = 64'h3FFFFFFFFFFFFFFE; - y = 64'hBFD0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBFE0000000000002; + y = 64'h401FFFFFFFBFEFFF; + z = 64'hBFBFFFFFFBFFFBFF; + ans = 64'h402FBFFFFFC7F005; rn = 1; rz = 0; rm = 0; @@ -38530,12 +124211,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1649465\n"); + $fwrite(fp,"1622187\n"); end - x = 64'hC3F23B5D47B0FEA9; - y = 64'hBFE0000000000000; - z = 64'hD9FFFFFFFFFFDFFF; - ans = 64'hD9FFFFFFFFFFDFFF; + x = 64'h3FD7C889A9DD25D9; + y = 64'h3FF0000000000001; + z = 64'hB7EFFF0001FFFFFE; + ans = 64'h3FD7C889A9DD25DA; rn = 1; rz = 0; rm = 0; @@ -38577,58 +124258,575 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1651479\n"); - end - x = 64'h414FF8FFFFFFFFFE; - y = 64'h380000004000001F; - z = 64'h8021FFFFFFFFFFFE; - ans = 64'h395FF9007FE4003C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1653493\n"); + $fwrite(fp,"1622801\n"); end x = 64'h3FFFFFFFFFFFFFFE; - y = 64'hBFF0000000000001; - z = 64'h3FF0000000000001; + y = 64'h37E38E855844BDB2; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1623415\n"); + end + x = 64'h3FBFFFFFFFFF8800; + y = 64'h404FFFFFBC000000; + z = 64'hC31FF80003FFFFFF; + ans = 64'hC31FF80003FFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1624029\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1624643\n"); + end + x = 64'hC3B00000FFFF7FFF; + y = 64'h0010000009FFFFFF; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1625257\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h4000000000000001; + z = 64'hB80B4B5C90860317; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1625871\n"); + end + x = 64'h000C37F7A56E5695; + y = 64'h2A72123EDDA1B8F9; + z = 64'hB910080000040000; + ans = 64'hB910080000040000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1626485\n"); + end + x = 64'h434FFFFFFD000000; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h436FFFFFFCFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1627099\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h405FC00004000000; + z = 64'hC1E0000001FFFFFC; + ans = 64'hC1DFFFFFC47FFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1627713\n"); + end + x = 64'hC1EFC00000004000; + y = 64'h4010000000000000; + z = 64'hCFC858BF316FDD04; + ans = 64'hCFC858BF316FDD04; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1628327\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h41EFFFFFFC3FFFFE; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h435000007FFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1628941\n"); + end + x = 64'hC5002000000001FE; + y = 64'h002FFFFF0000001E; + z = 64'hBF20800000000000; + ans = 64'hBF20800000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1629555\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1630169\n"); + end + x = 64'h0010000000020800; + y = 64'hBFC13358D21972CF; + z = 64'hBFEFFFFFFFFFFFFE; ans = 64'hBFEFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -38671,12 +124869,2127 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1655507\n"); + $fwrite(fp,"1630783\n"); end - x = 64'hC80FFFBBFFFFFFFE; + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h4340000000000000; + z = 64'h41D007FFFFFFF800; + ans = 64'h435000001007FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1631397\n"); + end + x = 64'h4760000020003FFF; + y = 64'hED03F987D1321ACA; + z = 64'h4940000001008000; + ans = 64'hF473F987F9257A51; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1632011\n"); + end + x = 64'hC3CFFDFFFFFFFF7F; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'hC72FFDFFFFFFFF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1632625\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hC7F001FFFFEFFFFF; + z = 64'hC1D0000000200FFF; + ans = 64'hC80001FFFFEFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1633239\n"); + end + x = 64'hC3FEDDFD05C7A4CA; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h401FFFFDF7FFFFFF; + ans = 64'hC75EDDFD05C7A4C8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1633853\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h8020007FFFFFBFFE; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1634467\n"); + end + x = 64'h4000002003FFFFFE; + y = 64'hBC4FFFFFBFFFFFFE; + z = 64'hBFBFFFFFFFFFE3FF; + ans = 64'hBFBFFFFFFFFFE400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1635081\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1635695\n"); + end + x = 64'hC6500004FFFFFFFE; + y = 64'h41DFFFC000008000; + z = 64'hBFE0000000000000; + ans = 64'hC83FFFC9FFEC7FFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1636309\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h7FFFFFFE000007FE; + ans = 64'h7FFFFFFE000007FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1636923\n"); + end + x = 64'h3FD0000000500000; + y = 64'h41C000001FFFDFFF; + z = 64'h40102011D91D9285; + ans = 64'h41A00000285FE8EC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1637537\n"); + end + x = 64'h43E000200FFFFFFF; + y = 64'h7FF0000000000001; + z = 64'h0000000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1638151\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h3596637D20B04D3A; + z = 64'hBF8106C2B0B30F67; + ans = 64'hBF8106C2B0B30F67; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1638765\n"); + end + x = 64'hBFF0000400007FFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h402FFFF000007FFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1639379\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h3CA351FEA32C59ED; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1639993\n"); + end + x = 64'hC03F7FFFFFFFFFE0; + y = 64'hC600000040400000; + z = 64'h9B87FF7FFFFFFFFF; + ans = 64'h464F80007E7DFFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1640607\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h8000000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1641221\n"); + end + x = 64'h3DE0002000000080; + y = 64'hBFE9F6F80CF16503; + z = 64'hBFD0000000000001; + ans = 64'hBFD000000019F72D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1641835\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC7F00000000005FE; + ans = 64'hC7F00000000005FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1642449\n"); + end + x = 64'hC00DFFF800000000; + y = 64'h401FDFFFFFFFFFFF; + z = 64'hC34B14F95370BE13; + ans = 64'hC34B14F95370BE22; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1643063\n"); + end + x = 64'hC011F773A1BF66A5; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1643677\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hB7FA19DC3A5A0D78; + z = 64'h3FDF7EFFFFFFFFFF; + ans = 64'h3FDF7EFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1644291\n"); + end + x = 64'hB028000000000FFF; + y = 64'h8010000000000001; + z = 64'hBFFFFF0000080000; + ans = 64'hBFFFFF0000080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1644905\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hFFD0000400000003; + z = 64'h4000000000000001; + ans = 64'hFFE0000400000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1645519\n"); + end + x = 64'hC1D0000000408000; + y = 64'h4CC000003FFFFF00; + z = 64'hBFBF7FC4A718A597; + ans = 64'hCEA0000040407F01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1646133\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1646747\n"); + end + x = 64'hC80FFF0000000002; + y = 64'hDF00FFFFDFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h6720FF77E0010000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1647361\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hBCA0000000000001; + z = 64'h3F8000000001FF00; + ans = 64'h3F8000000001FE80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1647975\n"); + end + x = 64'hC03B661E51E64B35; + y = 64'hBF0FFFFFFF7FFFEF; + z = 64'h41B7EF43DA372A52; + ans = 64'h41B7EF43DA3797EA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1648589\n"); + end + x = 64'h43CFFFFFFFFBFFFA; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1649203\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h572007FFFFFFFFEF; + z = 64'hC02C00B70D0083D1; + ans = 64'h573007FFFFFFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1649817\n"); + end + x = 64'hFFDFFFFFDBFFFFFF; + y = 64'hBFD0000000000000; + z = 64'h3CA0000020000008; + ans = 64'h7FBFFFFFDBFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1650431\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h3EB3A8C18215EEDE; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h400000013A8C1821; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1651045\n"); + end + x = 64'hAFBF4F812341AB31; + y = 64'h3F104001FFFFFFFF; + z = 64'h80114411054D7F17; + ans = 64'hAEDFCCC311BED644; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1651659\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC013FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1652273\n"); + end + x = 64'hC102BA21DE1A476C; + y = 64'hBECFFFFFF0000003; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h3FE2BA21D4BD367F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1652887\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hBFE0000000000000; + z = 64'hF9CFFFFF3FFFFFFE; + ans = 64'hF9CFFFFF3FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1653501\n"); + end + x = 64'h393FFDFFFFFFF800; + y = 64'h004E11D80A9D5AFF; + z = 64'h41F00003FF7FFFFF; + ans = 64'h41F00003FF7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1654115\n"); + end + x = 64'hC8000000000041FF; + y = 64'hBFE0000000000001; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'h47F0000000004200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1654729\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h43DFFFFFFFFFDFBF; + z = 64'hB800000000007FFC; + ans = 64'h43EFFFFFFFFFDFBD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1655343\n"); + end + x = 64'h665FFFFFFFF7F000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h41C000020001FFFE; + ans = 64'hE65FFFFFFFF7EFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1655957\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h401077A5A2BE365A; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h402277A5A2BE3659; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1656571\n"); + end + x = 64'h061FFFFFC1FFFFFF; + y = 64'hC070000040000400; + z = 64'hBFBF810000000000; + ans = 64'hBFBF810000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1657185\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hBFF0000000000001; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1657799\n"); + end + x = 64'h7FF6BBA8EE66553A; + y = 64'hD2200000017FFFFE; + z = 64'h8010000000000000; + ans = 64'h7FFEBBA8EE66553A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1658413\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hBF0000103FFFFFFE; - ans = 64'h481FFFBBFFFFFFFC; + z = 64'hBFE00400000FFFFE; + ans = 64'hC01200800001FFFE; rn = 1; rz = 0; rm = 0; @@ -38718,12 +127031,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1657521\n"); + $fwrite(fp,"1659027\n"); end - x = 64'hE09FF8003FFFFFFF; - y = 64'h4D3000000011FFFF; - z = 64'h40300FFFFFFFFFF6; - ans = 64'hEDDFF8004023F6FD; + x = 64'h7FDA73B4F67E128A; + y = 64'h7FF1FFFFFFFFFFFD; + z = 64'hCABF7FF800000000; + ans = 64'h7FF9FFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -38765,12 +127078,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1659535\n"); + $fwrite(fp,"1659641\n"); + end + x = 64'hAF60000009FFFFFE; + y = 64'hC000000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1660255\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h3FC7DE7FE710E06E; + z = 64'h3FFBFFFEFFFFFFFE; + ans = 64'h4000FBCF7CE21C0D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1660869\n"); + end + x = 64'hC04FFFFFFFC00007; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC1E000000FFFFF80; + ans = 64'hC1DFFFFFDFFFFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1661483\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h3FCC000010000000; + z = 64'h3FE0000000000000; + ans = 64'h3FEE000007FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1662097\n"); + end + x = 64'hC3F2E37F64E0E0B4; + y = 64'hB96F00000FFFFFFE; + z = 64'hC1DFE00400000000; + ans = 64'hC1DFE00400000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1662711\n"); end x = 64'h3FFFFFFFFFFFFFFE; y = 64'hC010000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000004; + z = 64'hBFF0000000000000; + ans = 64'hC021FFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -38812,12 +127360,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1661549\n"); + $fwrite(fp,"1663325\n"); end - x = 64'h3FF003FFFFFEFFFF; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hC5404000003FFFFF; - ans = 64'hC5404000003FFFFF; + x = 64'hB7BFDFFFFFFF0000; + y = 64'hA7FF7FFEFFFFFFFE; + z = 64'h8000000000000001; + ans = 64'h1FCF607F00FF03FE; rn = 1; rz = 0; rm = 0; @@ -38859,57 +127407,2877 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1663563\n"); - end - x = 64'hBFBF80000001FFFF; - y = 64'h3F3FFFFFFFEFFFDF; - z = 64'h3FC573070215E3AE; - ans = 64'h3FC5710F0215E48A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1665577\n"); + $fwrite(fp,"1663939\n"); end x = 64'h3FFFFFFFFFFFFFFE; - y = 64'hFFE0000000000000; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hEC562C4E9A8A0F85; + ans = 64'hEC562C4E9A8A0F85; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1664553\n"); + end + x = 64'hBDB000000FFFFC00; + y = 64'h402A95C63B51BA70; + z = 64'hB816D59A68BD29ED; + ans = 64'hBDEA95C655E77A06; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1665167\n"); + end + x = 64'hC1C2DEC562387EB0; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hC010000000000001; + ans = 64'h41F2DEC561F87EAF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1665781\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hBCAFF0000007FFFE; + z = 64'h403FBFFFFFBFFFFF; + ans = 64'h403FBFFFFFBFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1666395\n"); + end + x = 64'hC1BFDFF7FFFFFFFF; + y = 64'hC340000000000001; + z = 64'hFFD20668823AB724; + ans = 64'hFFD20668823AB724; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1667009\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h45F7FFC000000000; + z = 64'h3FD0000000000001; + ans = 64'h4607FFBFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1667623\n"); + end + x = 64'hC340000000107FFF; + y = 64'h40DD42F951360FAA; + z = 64'h40FFFFDFFFFFFFFB; + ans = 64'hC42D42F951543CB5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1668237\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hBFE0000000000001; + ans = 64'hC35FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1668851\n"); + end + x = 64'hBFDFF02000000000; + y = 64'hC3EFFFFFFFFFFB7F; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1669465\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hFFE0000000000001; + z = 64'hC020088000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1670079\n"); + end + x = 64'hC7EFFFFFE00003FF; + y = 64'hC1F1FFF7FFFFFFFE; + z = 64'h3CBE81B9C620397C; + ans = 64'h49F1FFF7EE000A3D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1670693\n"); + end + x = 64'hC342F1C3ADA6D99F; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1671307\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h3C8FE1FFFFFFFFFF; + z = 64'h39C07FEFFFFFFFFF; + ans = 64'h3C9FE20000000081; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1671921\n"); + end + x = 64'hA2345AA3A1084924; + y = 64'hFFF0000000000000; + z = 64'hB8104000FFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1672535\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h41CBFFFFFFFFE000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h41DBFFFFFFFFDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1673149\n"); + end + x = 64'hB96FFFFFFFFFF77E; + y = 64'h49AFFFBFFFFE0000; + z = 64'h5CDF7FEFFFFFFFFF; + ans = 64'h5CDF7FEFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1673763\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1674377\n"); + end + x = 64'h400FFFC0000FFFFE; + y = 64'h802FE000001FFFFF; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1674991\n"); + end + x = 64'h4000000000000000; + y = 64'h0000000000000000; + z = 64'h001000FFFFFC0000; + ans = 64'h001000FFFFFC0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1675605\n"); + end + x = 64'h37E743D23F8C0702; + y = 64'h407042B6B14E36BF; + z = 64'hB3EFFFFFF7FFFFBF; + ans = 64'h3867A4D3A819BB92; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1676219\n"); + end + x = 64'h524001FF00000000; + y = 64'h0000000000000001; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1676833\n"); + end + x = 64'h4000000000000000; + y = 64'h4F02493E952EEE02; + z = 64'h0A9F0000FFFFFFFF; + ans = 64'h4F12493E952EEE02; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1677447\n"); + end + x = 64'hBFD3DB57D4E982A8; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h801FF80000007FFF; + ans = 64'h8022776AFA9D7054; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1678061\n"); + end + x = 64'h4000000000000000; + y = 64'h0AEFF00000040000; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h0AFFF00000040000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1678675\n"); + end + x = 64'h37EFFFFFFFC03FFF; + y = 64'h41E000003FFC0000; + z = 64'hC3DFFF0000000100; + ans = 64'hC3DFFF0000000100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1679289\n"); + end + x = 64'h4000000000000000; + y = 64'h0010000000000001; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1679903\n"); + end + x = 64'h41EB000000000000; + y = 64'h4063494AAD05F0DE; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1680517\n"); + end + x = 64'h4000000000000000; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h41EFFFFF00007FFF; + ans = 64'h41EFFFFF00007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1681131\n"); + end + x = 64'hC341FFFFFFFDFFFF; + y = 64'h002FFFFFFF7FBFFF; + z = 64'hC03112A588EFBE99; + ans = 64'hC03112A588EFBE99; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1681745\n"); + end + x = 64'h001C0C4BE24F40FD; + y = 64'h3CA0000000000000; + z = 64'hBFF0000000000000; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1682359\n"); + end + x = 64'h4000000000000000; + y = 64'h3FF524055197547C; + z = 64'hBF1EB55F1B5292BA; + ans = 64'h400523C7E6D91DD7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1682973\n"); + end + x = 64'hC0D50A2D635E365F; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h41F6244AC1402982; + ans = 64'h41F6244AC1402982; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1683587\n"); + end + x = 64'h4000000000000000; + y = 64'h3FE0000007C00000; + z = 64'h0010000000000000; + ans = 64'h3FF0000007C00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1684201\n"); + end + x = 64'hB80FE000001FFFFE; + y = 64'hBFF00000107FFFFF; + z = 64'h405000040000000F; + ans = 64'h405000040000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1684815\n"); + end + x = 64'h4000000000000000; + y = 64'h3FD0000000000000; + z = 64'hBCA0000000000000; + ans = 64'h3FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1685429\n"); + end + x = 64'hBFDFFBFFFFFBFFFF; + y = 64'h480FFDFFFFFFFF00; + z = 64'h4340000000000001; + ans = 64'hC7FFFA003FFBFF3F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1686043\n"); + end + x = 64'h4000000000000000; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h000F6C9C104B7ABB; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1686657\n"); + end + x = 64'hC02FFFFFFF080000; + y = 64'h43EAECF0AEF79302; + z = 64'hFFDFFFFFF00001FF; + ans = 64'hFFDFFFFFF00001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1687271\n"); + end + x = 64'h3CA00FFDFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1687885\n"); + end + x = 64'h4000000000000000; + y = 64'h0001B09F750C484A; + z = 64'hBFCFF80001FFFFFF; + ans = 64'hBFCFF80001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1688499\n"); + end + x = 64'h403FF80001FFFFFF; + y = 64'h3FE0000000000001; + z = 64'h41CFFFEFFFFFE000; + ans = 64'h41CFFFF007FDE001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1689113\n"); + end + x = 64'h4000000000000000; + y = 64'h425EFFFFFFFFFFBF; + z = 64'h0000000000000001; + ans = 64'h426EFFFFFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1689727\n"); + end + x = 64'h43F2000000000100; + y = 64'hC0AFBFFFFFFFFFFE; + z = 64'hC01FE0000007FFFF; + ans = 64'hC4B1DC00000000FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1690341\n"); + end + x = 64'h4000000000000000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h8010000000000001; + ans = 64'h3FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1690955\n"); + end + x = 64'hC020003FF7FFFFFF; + y = 64'hC7E803FFFFFFFFFE; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h4818046003FDFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1691569\n"); + end + x = 64'h4000000000000000; + y = 64'h3FF0000000000001; + z = 64'hC028C4AD1E629470; + ans = 64'hC024C4AD1E629470; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1692183\n"); + end + x = 64'h41EFF80000010000; + y = 64'h41FFFFFFC000FFFE; + z = 64'hB81FFFFF03FFFFFE; + ans = 64'h43FFF7FFC011FFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1692797\n"); + end + x = 64'h7FDE000000000FFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h7FEE000000000FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1693411\n"); + end + x = 64'h4000000000000000; + y = 64'h466FFFFF77FFFFFE; + z = 64'h41F0000040200000; + ans = 64'h467FFFFF77FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1694025\n"); + end + x = 64'hC1CFFFFDDFFFFFFF; + y = 64'h4000000000000000; + z = 64'hBEBA2BDB90324F31; + ans = 64'hC1DFFFFDE0000006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1694639\n"); + end + x = 64'h4000000000000000; + y = 64'h37E0000000008FFF; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1695253\n"); + end + x = 64'h43D0000008000FFE; + y = 64'hB81FFFFF7FFFFF80; + z = 64'hC3E0007FFFFFBFFE; + ans = 64'hC3E0007FFFFFBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1695867\n"); + end + x = 64'h4000000000000000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1696481\n"); + end + x = 64'hC281963398C5F833; + y = 64'hC3C0000100000003; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h46519634B22931C3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1697095\n"); + end + x = 64'h4000000000000000; + y = 64'h4010000000000000; + z = 64'hBAFFFFC000000010; + ans = 64'h4020000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1697709\n"); + end + x = 64'h400F800001FFFFFE; + y = 64'hBCA0000000000090; + z = 64'h53400000801FFFFF; + ans = 64'h53400000801FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1698323\n"); + end + x = 64'h35E0004003FFFFFE; + y = 64'h4010000000000001; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1698937\n"); + end + x = 64'h4000000000000000; + y = 64'h37FFFFFBFFDFFFFE; + z = 64'hBFB9F6ED561680FF; + ans = 64'hBFB9F6ED561680FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1699551\n"); + end + x = 64'h7FD00000003DFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hBFD0FFFFFFFFFEFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1700165\n"); + end + x = 64'h4000000000000000; + y = 64'hBFB000FFFFFFFFC0; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1700779\n"); + end + x = 64'hFFE000000008000E; + y = 64'h41F00000201FFFFF; + z = 64'h4730007800000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1701393\n"); + end + x = 64'h4000000000000000; + y = 64'h4340000000000001; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -38953,12 +130321,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1667591\n"); + $fwrite(fp,"1702007\n"); end - x = 64'hBFC48FB834ECE0DD; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hC00FEFFFFFFEFFFE; - ans = 64'h7FC48FB834ECE0DC; + x = 64'hCE41BA3F359D9A50; + y = 64'hC00E3FFFFFFFFFFF; + z = 64'h4000000000000000; + ans = 64'h4E60C20FC0AEFBDF; rn = 1; rz = 0; rm = 0; @@ -39000,59 +130368,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1669605\n"); - end - x = 64'hC01FFF7FFFBFFFFF; - y = 64'hFF3E51ACA009FA27; - z = 64'h8010000400020000; - ans = 64'h7F6E5133591AD6A5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1671619\n"); + $fwrite(fp,"1702621\n"); end x = 64'h4000000000000000; - y = 64'h0000000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hBFCFF8000000003E; + ans = 64'h435FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -39094,12 +130415,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1673633\n"); + $fwrite(fp,"1703235\n"); end - x = 64'hBFBFFFFF007FFFFF; - y = 64'h000FFFFFFFFFFFFF; - z = 64'h000BFFFFFFC00000; - ans = 64'h000A00000FB80000; + x = 64'hC345C210B27A7C55; + y = 64'hD04FFDFFFFFFFC00; + z = 64'hBFE7FFFE00000000; + ans = 64'h53A5C0B4916F51F5; rn = 1; rz = 0; rm = 0; @@ -39141,12 +130462,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1675647\n"); + $fwrite(fp,"1703849\n"); end - x = 64'h3EEFFFFFFFFFFBFE; - y = 64'hBFA78BDE48D46AE7; - z = 64'hBE6413896FF4D5BD; - ans = 64'hBEA8CD16DFD3B550; + x = 64'h7FD0000000001FFB; + y = 64'h7FE0000000000000; + z = 64'hBCA0000000000000; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -39188,10 +130509,2219 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1677661\n"); + $fwrite(fp,"1704463\n"); end x = 64'h4000000000000000; - y = 64'h001FFFFFFFFFFFFE; + y = 64'hC0001FFFFFFFFFDF; + z = 64'h3E3000007FFFF7FF; + ans = 64'hC0101FFFFFBFFFDD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1705077\n"); + end + x = 64'h37FB660C620F438B; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h436FFFFFF7FFFBFF; + ans = 64'h77FB660C620F438A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1705691\n"); + end + x = 64'h4000000000000000; + y = 64'hBE9E5650DF91EE0C; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1706305\n"); + end + x = 64'hC7E0008080000000; + y = 64'hC629AB6B7F281634; + z = 64'h001001FF7FFFFFFF; + ans = 64'h4E19AC39A7DF6B6E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1706919\n"); + end + x = 64'h4000000000000000; + y = 64'h7FF0000000000000; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1707533\n"); + end + x = 64'h3FCDD2DC2964A124; + y = 64'h43D0000038000000; + z = 64'h3FF0000000000001; + ans = 64'h43ADD2DC91C6A3B5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1708147\n"); + end + x = 64'h4000000000000000; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h4C2FFFFF7FFFFFBF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1708761\n"); + end + x = 64'hE3E00FFFFFFC0000; + y = 64'hC3D000000000005E; + z = 64'h4A4D8898DFF8B465; + ans = 64'h67C00FFFFFFC005E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1709375\n"); + end + x = 64'h001000080001FFFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h8010000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1709989\n"); + end + x = 64'h4000000000000000; + y = 64'h3FF00000107FFFFF; + z = 64'hC03FEFFFFE000000; + ans = 64'hC03DEFFFFBF00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1710603\n"); + end + x = 64'h47FF17EBE05658B2; + y = 64'h8000000000000001; + z = 64'h6C2FFFFFFFFFF5FE; + ans = 64'h6C2FFFFFFFFFF5FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1711217\n"); + end + x = 64'h4000000000000000; + y = 64'hC2AFFFFFFFFFFCFE; + z = 64'hC340000000000001; + ans = 64'hC3400FFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1711831\n"); + end + x = 64'h3204CCAB7A4D2D0C; + y = 64'hBC01FFFFFFFFFDFE; + z = 64'hFFEF7FFFFFF7FFFF; + ans = 64'hFFEF7FFFFFF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1712445\n"); + end + x = 64'h4000000000000000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1713059\n"); + end + x = 64'hBFF000007DFFFFFF; + y = 64'hBFE89D55BBC01104; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FFC4EAB3ECB8A14; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1713673\n"); + end + x = 64'h4000000000000000; + y = 64'h8010000000000000; + z = 64'h380FFF00000001FF; + ans = 64'h380FFF00000001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1714287\n"); + end + x = 64'hB9B000080000003F; + y = 64'hB93FFFFFFFFE0001; + z = 64'hBFD1698896277BD3; + ans = 64'hBFD1698896277BD3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1714901\n"); + end + x = 64'h400FEFE000000000; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h8041F7EFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1715515\n"); + end + x = 64'h4000000000000000; + y = 64'h40D00000000FFF7E; + z = 64'h40000000003FDFFF; + ans = 64'h40E000400010007D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1716129\n"); + end + x = 64'hC723258BFDA071ED; + y = 64'hBCA0000000000000; + z = 64'h3FB0000000200001; + ans = 64'h43D3258BFDA071ED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1716743\n"); + end + x = 64'h4000000000000000; + y = 64'h80200101FFFFFFFE; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1717357\n"); + end + x = 64'h41E0000DFFFFFFFF; + y = 64'h412000000000801E; + z = 64'hBFAFFFFFFFFE0007; + ans = 64'h4310000E0000801D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1717971\n"); + end + x = 64'h4000000000000000; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1718585\n"); + end + x = 64'hFFEFFFFFFFFFF7FE; + y = 64'h47F000000003FFFF; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1719199\n"); + end + x = 64'h4000000000000000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hB16000003FFFFFFF; + ans = 64'hBCBFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1719813\n"); + end + x = 64'h43C53AE0E828B89B; + y = 64'hB8D2000000010000; + z = 64'h400FEFFFFFFFFFFD; + ans = 64'h400FEFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1720427\n"); + end + x = 64'h016BFFFFFFFFBFFF; + y = 64'hBFD0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1721041\n"); + end + x = 64'h4000000000000000; + y = 64'h47E001FFFF800000; + z = 64'h480420C387510B53; + ans = 64'h480C21C387110B53; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1721655\n"); + end + x = 64'hC3C087FFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hC02FFFFFFFFFFFF2; + ans = 64'h43B087FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1722269\n"); + end + x = 64'h4000000000000000; + y = 64'h7FE0000037FFFFFE; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1722883\n"); + end + x = 64'hC1DFFFFEFFFF7FFE; + y = 64'h402FFFFFDEFFFFFF; + z = 64'h4F515204563A7F36; + ans = 64'h4F515204563A7F36; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1723497\n"); + end + x = 64'h4000000000000000; + y = 64'hBFE0000000000001; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401BFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1724111\n"); + end + x = 64'h40100200000007FF; + y = 64'h47EFF7FFFFFFFFF0; + z = 64'h3FD0000000000000; + ans = 64'h480FFBFF00000FEA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1724725\n"); + end + x = 64'h4000000000000000; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h401FFFFFFF880000; + ans = 64'h4017FFFFFF880000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1725339\n"); + end + x = 64'hB806261012190A5F; + y = 64'hC343FFFFFFFFFFDE; + z = 64'h402830644E65DDF0; + ans = 64'h402830644E65DDF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1725953\n"); + end + x = 64'h47F927AEB72E590C; + y = 64'hBFF0000000000000; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1726567\n"); + end + x = 64'h4000000000000000; + y = 64'h755EA63AFBFA49E3; + z = 64'h6FBFFFE000000000; + ans = 64'h756EA63AFBFA49E3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1727181\n"); + end + x = 64'hC1DFFFFFFC000800; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h8151008000000000; + ans = 64'h41EFFFFFFC0007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1727795\n"); + end + x = 64'h4000000000000000; + y = 64'hBFE00000FFBFFFFE; + z = 64'hC000000000000000; + ans = 64'hC00800007FDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1728409\n"); + end + x = 64'hC4E00000004007FF; + y = 64'hB7E400000000007F; + z = 64'h37E0000000040002; + ans = 64'h3CD4000000500A7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1729023\n"); + end + x = 64'h4000000000000000; + y = 64'hC000000000000000; + z = 64'h4010000000000000; + ans = 64'h0000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1729637\n"); + end + x = 64'h47F9AFC4E5492F7B; + y = 64'h409E22E8C3182C5E; + z = 64'h3CA0000000000001; + ans = 64'h48A830CE2F1637DE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1730251\n"); + end + x = 64'h4000000000000000; + y = 64'hC000000000000001; + z = 64'hBF6FFFFF5FFFFFFF; + ans = 64'hC01003FFFFEC0001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1730865\n"); + end + x = 64'h4030000002000000; + y = 64'hC25FFFDFFFFFFFFF; + z = 64'hC0040000001FFFFF; + ans = 64'hC29FFFE0040005FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1731479\n"); + end + x = 64'h4010000400000006; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1732093\n"); + end + x = 64'h4000000000000000; + y = 64'h43F0FFFFFEFFFFFF; + z = 64'h3FBFFFFE00000002; + ans = 64'h4400FFFFFEFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1732707\n"); + end + x = 64'h40300146660A8F48; + y = 64'hC010000000000000; + z = 64'hBFC00FFFFFFFF800; + ans = 64'hC050094E660A8F44; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1733321\n"); + end + x = 64'h4000000000000000; + y = 64'h25F0DFEF7CAE8B52; z = 64'hBFF0000000000001; ans = 64'hBFF0000000000001; rn = 1; @@ -39235,12 +132765,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1679675\n"); + $fwrite(fp,"1733935\n"); end - x = 64'h47F0000002000000; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'hC5FFFDFFFFFFE000; - ans = 64'hC5FFFDFEFFFFDFE0; + x = 64'hC3F0800003FFFFFF; + y = 64'h40F00000001EFFFF; + z = 64'hC18FFFFFFFFDEFFF; + ans = 64'hC4F08000041FF7FE; rn = 1; rz = 0; rm = 0; @@ -39282,59 +132812,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1681689\n"); - end - x = 64'h3E707FFFFFFFFEFE; - y = 64'h401FFFFFDF000000; - z = 64'h8000DF3AAECD13EB; - ans = 64'h3EA07FFFEEFBFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1683703\n"); + $fwrite(fp,"1734549\n"); end x = 64'h4000000000000000; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h4000000000000001; + ans = 64'hC02BFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -39376,12 +132859,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1685717\n"); + $fwrite(fp,"1735163\n"); end - x = 64'hBEFFFFD000000000; - y = 64'h3FE0000000000001; - z = 64'hC3D0000000007FBE; - ans = 64'hC3D0000000007FBE; + x = 64'hC37FFFFFFFF3FFFF; + y = 64'h401FFFFFFFFFF600; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hC3AFFFFFFFF3F5FF; rn = 1; rz = 0; rm = 0; @@ -39423,59 +132906,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1687731\n"); - end - x = 64'hC80FFFFFFFF7FFF6; - y = 64'h400FFFFEFFFFBFFF; - z = 64'hBFB38D0D6D9F1DF5; - ans = 64'hC82FFFFEFFF7BFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1689745\n"); + $fwrite(fp,"1735777\n"); end x = 64'h4000000000000000; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + y = 64'hC340000000000000; + z = 64'h4031000008000000; + ans = 64'hC34FFFFFFFFFFFF7; rn = 1; rz = 0; rm = 0; @@ -39517,12 +132953,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1691759\n"); + $fwrite(fp,"1736391\n"); end - x = 64'hFFD000000000000F; - y = 64'h4000000000000001; - z = 64'hBEE727C6C2939AC7; - ans = 64'hFFE0000000000010; + x = 64'hBFBFFFFF8000FFFF; + y = 64'h404000004000000F; + z = 64'h3C1FC1FFFFFFFFFE; + ans = 64'hC010000000007F0F; rn = 1; rz = 0; rm = 0; @@ -39564,246 +133000,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1693773\n"); + $fwrite(fp,"1737005\n"); end - x = 64'hBECFFFFFF8000003; - y = 64'h2EB5B3F4AF3D7BF6; - z = 64'h41307FFFFFFFFFBF; - ans = 64'h41307FFFFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1695787\n"); - end - x = 64'h4000000000000000; - y = 64'h401FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h402FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1697801\n"); - end - x = 64'hBFD0FFFFF7FFFFFF; - y = 64'h4340000000000001; - z = 64'hC0B0002000001FFE; - ans = 64'hC320FFFFF8002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1699815\n"); - end - x = 64'h3FC03FFFFFFFFFF7; - y = 64'hFFEAD8BEE9B8973A; - z = 64'h3FEF000008000000; - ans = 64'hFFBB4421E55F7988; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1701829\n"); - end - x = 64'h4000000000000000; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1703843\n"); - end - x = 64'hC4A72CA6B0DBBC07; - y = 64'h7FF0000000000000; - z = 64'h3C340000000000FF; + x = 64'h7CCFFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h434FFFFFFFFFFFFF; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -39846,59 +133047,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1705857\n"); - end - x = 64'h3FB000101FFFFFFF; - y = 64'hB0D2D32BC2E62804; - z = 64'h8010002007FFFFFF; - ans = 64'hB092D33EBBB8426F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1707871\n"); + $fwrite(fp,"1737619\n"); end x = 64'h4000000000000000; - y = 64'h8000000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + y = 64'h2ADFC00004000000; + z = 64'hB16FFFFFE00FFFFF; + ans = 64'hB16FFFFFE00FFFFF; rn = 1; rz = 0; rm = 0; @@ -39940,12 +133094,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1709885\n"); + $fwrite(fp,"1738233\n"); end - x = 64'h0000FF0000000000; - y = 64'h8010000000000000; - z = 64'hC000000401FFFFFE; - ans = 64'hC000000401FFFFFE; + x = 64'hC3DF7FFBFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hBFC0DB4FA7E69FC7; + ans = 64'h473F7FFBFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -39987,59 +133141,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1711899\n"); - end - x = 64'hC0332683837CE949; - y = 64'hC0F000000800FFFF; - z = 64'h41E0000000000FFF; - ans = 64'h41E00264D071B22B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1713913\n"); + $fwrite(fp,"1738847\n"); end x = 64'h4000000000000000; - y = 64'hBCA0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + y = 64'hC1FFFFFDFFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hC20FFFFE0007FFFE; rn = 1; rz = 0; rm = 0; @@ -40081,12 +133188,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1715927\n"); + $fwrite(fp,"1739461\n"); end - x = 64'h4A1003FFFF7FFFFF; - y = 64'hBFD0000000000000; - z = 64'h3CA000FFFFFFF000; - ans = 64'hC9F003FFFF7FFFFF; + x = 64'h3F0077FFFFFFFFFF; + y = 64'h3FCC000000020000; + z = 64'h43DF1D64DBAB2499; + ans = 64'h43DF1D64DBAB2499; rn = 1; rz = 0; rm = 0; @@ -40128,59 +133235,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1717941\n"); - end - x = 64'hC00DFFFFFFFFEFFF; - y = 64'hBE500003FEFFFFFF; - z = 64'h39CFFFFEFFFFFFBF; - ans = 64'h3E6E00077E1FEFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1719955\n"); + $fwrite(fp,"1740075\n"); end x = 64'h4000000000000000; - y = 64'hBFE0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hBFF0000000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -40222,12 +133282,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1721969\n"); + $fwrite(fp,"1740689\n"); end - x = 64'hC1D0001000200000; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hBB000010FFFFFFFE; - ans = 64'h41D00010001FFFFF; + x = 64'h41F400000001FFFE; + y = 64'h40800FFFFEFFFFFF; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h428413FFFEC201FD; rn = 1; rz = 0; rm = 0; @@ -40269,341 +133329,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1723983\n"); - end - x = 64'hBFD00203FFFFFFFF; - y = 64'h40E8CD2DEA9DB561; - z = 64'hE40FE0000000FFFF; - ans = 64'hE40FE0000000FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1725997\n"); - end - x = 64'h4000000000000000; - y = 64'hC000000000000000; - z = 64'hBFF0000000000001; - ans = 64'hC014000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1728011\n"); - end - x = 64'hBFCFBFFFFFFFFBFF; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'h381E7BECF1508167; - ans = 64'h3FEFBFFFFFFFFBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1730025\n"); - end - x = 64'hC1DF000000004000; - y = 64'h3E46552EF24D77CA; - z = 64'h402403FFFFFFFFFF; - ans = 64'hC027410AF576716D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1732039\n"); - end - x = 64'h4000000000000000; - y = 64'hC340000000000000; - z = 64'h4340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1734053\n"); - end - x = 64'hBD6FFFF800000040; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hC06FFFFFFA000000; - ans = 64'h40CF7FF80018003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1736067\n"); - end - x = 64'h4B3FFFFFFFFFE010; - y = 64'hC12FFF7FFFE00000; - z = 64'hBF6EE7B3B6726BD9; - ans = 64'hCC7FFF7FFFDFE010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1738081\n"); + $fwrite(fp,"1741303\n"); end x = 64'h4000000000000000; y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + z = 64'hC06FFFFDFFFFFE00; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -40645,11 +133376,152 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1740095\n"); + $fwrite(fp,"1741917\n"); end - x = 64'hBC5FFFFFFFFFFCFE; + x = 64'h3F70000F7FFFFFFE; + y = 64'h40FE955D3D060580; + z = 64'h3FD0FFFFFDFFFFFE; + ans = 64'h407E99BADDB7D89A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1742531\n"); + end + x = 64'hC7E0FFFFE0000000; + y = 64'hFFF0000000000001; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1743145\n"); + end + x = 64'h4000000000000000; + y = 64'hC3FF3DB5443DB0CB; + z = 64'h43ECD85389B5C822; + ans = 64'hC40807A061D03EC2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1743759\n"); + end + x = 64'hC7FFFFFFF0001FFE; y = 64'hFFFFFFFFFFFFFFFF; - z = 64'hBCA00000008000FF; + z = 64'h0000006FFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -40692,12 +133564,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1742109\n"); + $fwrite(fp,"1744373\n"); end - x = 64'h64D000001FFFF7FF; - y = 64'h4A300000007FBFFF; - z = 64'h41C0000FFFF00000; - ans = 64'h6F100000207FB7FF; + x = 64'h4000000000000000; + y = 64'h5851433A0C36872F; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h5861433A0C36872F; rn = 1; rz = 0; rm = 0; @@ -40739,12 +133611,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1744123\n"); + $fwrite(fp,"1744987\n"); + end + x = 64'hC09FF7BFFFFFFFFF; + y = 64'h3800000000000FC0; + z = 64'hBE7000000000000E; + ans = 64'hBE7000000000000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1745601\n"); end x = 64'h4000000000000001; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; + y = 64'h0000000000000001; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -40786,12 +133705,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1746137\n"); + $fwrite(fp,"1746215\n"); end - x = 64'hC340000000004100; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h3FB9F4A28A317BA3; - ans = 64'h3FB9F4A28A317BA3; + x = 64'hFFD9F43EFD1ADAF1; + y = 64'h3FF4CC80FA5A7FC4; + z = 64'h0000000000000000; + ans = 64'hFFE0DE850BC7DB21; rn = 1; rz = 0; rm = 0; @@ -40833,59 +133752,529 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1748151\n"); - end - x = 64'hAC733AF5CC6534E5; - y = 64'hBFBFFFFFFFFFE003; - z = 64'hBE7FFFFFFF800040; - ans = 64'hBE7FFFFFFF800040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1750165\n"); + $fwrite(fp,"1746829\n"); end x = 64'h4000000000000001; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC18FFFFFFFCFFFFE; + ans = 64'hC18FFFFFFFCFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1747443\n"); + end + x = 64'hC51F224DF686F6E9; + y = 64'hBF77FFFFFFFFFBFF; + z = 64'h3811FFFFFFFFEFFF; + ans = 64'h44A759BA78E53549; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1748057\n"); + end + x = 64'hC800000000007FFB; + y = 64'h0010000000000000; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1748671\n"); + end + x = 64'h4000000000000001; + y = 64'h38900000000FFFBF; + z = 64'h331583B66DB45ACA; + ans = 64'h38A00000000FFFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1749285\n"); + end + x = 64'hC00FFFFFFC002000; + y = 64'h0010000000000001; + z = 64'h813DEEFF25B99912; + ans = 64'h813DEF0F25B99712; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1749899\n"); + end + x = 64'h4000000000000001; + y = 64'h400000000100007F; + z = 64'hBFD0000000000000; + ans = 64'h400E000002000100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1750513\n"); + end + x = 64'hC7E0FFFFFF7FFFFF; + y = 64'h3F89E348A0C8D43A; + z = 64'h801FB486830D7FB5; + ans = 64'hC77B817D2A064737; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1751127\n"); + end + x = 64'h4000000000000001; + y = 64'h3CA0000000000000; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1751741\n"); + end + x = 64'h436D6341228748EE; + y = 64'h242000000FFFBFFF; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1752355\n"); + end + x = 64'h4000000000000001; + y = 64'h3CA0000000000001; + z = 64'h43D0000000004400; + ans = 64'h43D0000000004400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1752969\n"); + end + x = 64'h801FFFFFBF000000; + y = 64'h4012B6DA70C3DECC; + z = 64'h0000000000000006; + ans = 64'h8042B6DA4AC07316; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1753583\n"); + end + x = 64'hBFDF803FFFFFFFFE; y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000003; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; rn = 1; rz = 0; rm = 0; @@ -40927,106 +134316,388 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1752179\n"); - end - x = 64'hC34407FFFFFFFFFF; - y = 64'h3FD0000000000001; - z = 64'h434EE78A270158C4; - ans = 64'h4349E58A270158C4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1754193\n"); - end - x = 64'hBEF0000040002000; - y = 64'hC00FFFDFFFFEFFFF; - z = 64'h3F94C3676CE5C5C1; - ans = 64'h3F94D3675D25C521; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1756207\n"); + $fwrite(fp,"1754197\n"); end x = 64'h4000000000000001; + y = 64'h358FFFFFEFFFFFFE; + z = 64'hBF8FFFFFFFFFFFFE; + ans = 64'hBF8FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1754811\n"); + end + x = 64'hBFCFFEFFFFFFF7FE; + y = 64'h3FD0000000000000; + z = 64'h3FDFFFFFFFFF77FF; + ans = 64'h3FDC001FFFFF78FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1755425\n"); + end + x = 64'h4000000000000001; + y = 64'h3FCFFFFFFFFC01FF; + z = 64'hBCA0000000000001; + ans = 64'h3FDFFFFFFFFC01FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1756039\n"); + end + x = 64'h37F0000000801FFF; + y = 64'h37EFFFFFF001FFFF; + z = 64'h800FFFFFC0FFFFFE; + ans = 64'h2FEFFFFFF1023FFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1756653\n"); + end + x = 64'h4000000000000001; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3FD0000000000001; + ans = 64'h3FF4000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1757267\n"); + end + x = 64'h43D0000004800000; + y = 64'hB91FFBFFFFFFFEFE; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1757881\n"); + end + x = 64'h4000000000000001; + y = 64'h3FE0000000000000; + z = 64'hC3D000000077FFFF; + ans = 64'hC3D000000077FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1758495\n"); + end + x = 64'h3FB00000040003FF; + y = 64'h3FD0000020800000; + z = 64'h3FEFF7FFFFEFFFFF; + ans = 64'h3FF03C00008A0010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1759109\n"); + end + x = 64'hAB0FFFFFF0100000; y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFFE; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -41068,106 +134739,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1758221\n"); - end - x = 64'h3C5FC00000000000; - y = 64'h3FF0000000000001; - z = 64'hC3400013FFFFFFFE; - ans = 64'hC3400013FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1760235\n"); - end - x = 64'hB7FFFFFF807FFFFF; - y = 64'h4000000000014000; - z = 64'h40B000400000001E; - ans = 64'h40B000400000001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1762249\n"); + $fwrite(fp,"1759723\n"); end x = 64'h4000000000000001; - y = 64'h400FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + y = 64'hC1C5B002CE2BD351; + z = 64'hB80337F20C2B93AE; + ans = 64'hC1D5B002CE2BD352; rn = 1; rz = 0; rm = 0; @@ -41209,12 +134786,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1764263\n"); + $fwrite(fp,"1760337\n"); end - x = 64'hC3FAF4D1799B420E; - y = 64'h4010000000000001; - z = 64'hC3335809BE152176; - ans = 64'hC41AF51ED9C23A64; + x = 64'h4800000400400000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hC3CBC6C815066223; + ans = 64'h48000004003FFFFF; rn = 1; rz = 0; rm = 0; @@ -41256,59 +134833,106 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1766277\n"); - end - x = 64'h4020FEFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h402FC3FFFFFFFFFE; - ans = 64'hC04A0CFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1768291\n"); + $fwrite(fp,"1760951\n"); end x = 64'h4000000000000001; - y = 64'h434FFFFFFFFFFFFF; + y = 64'hBFDFFF7FFFFFFFFD; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'hBFEFFF7FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1761565\n"); + end + x = 64'h400F9D7BCAC61F20; + y = 64'h47FF0000001FFFFF; + z = 64'hC00D1C5E24468EF4; + ans = 64'h481EA08FEC8F8BA2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1762179\n"); + end + x = 64'h4000000000000001; + y = 64'h3FFFFFFFFFFFFFFF; z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h4360000000000000; + ans = 64'h4010000000000001; rn = 1; rz = 0; rm = 0; @@ -41350,12 +134974,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1770305\n"); + $fwrite(fp,"1762793\n"); end - x = 64'hFFF13EF189994B39; - y = 64'h7FE0000000000000; - z = 64'hC80FFF7FFC000000; - ans = 64'hFFF93EF189994B39; + x = 64'h3FF01FFFFFFFFF7F; + y = 64'h400FFFFFFFFEFFFC; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -41397,59 +135021,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1772319\n"); - end - x = 64'h41F00000007FE000; - y = 64'hCEFF8000000003FF; - z = 64'h445FFFFFFFFFFFFF; - ans = 64'hD0FF800000FBC4FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1774333\n"); + $fwrite(fp,"1763407\n"); end x = 64'h4000000000000001; - y = 64'h7FF0000000000001; - z = 64'hBFF0000000000001; - ans = 64'h7FF8000000000001; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h4030000010000400; + ans = 64'h4034000010000400; rn = 1; rz = 0; rm = 0; @@ -41491,12 +135068,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1776347\n"); + $fwrite(fp,"1764021\n"); end - x = 64'hC3E0000FFFFFFFFE; - y = 64'h8000000000000000; - z = 64'hFFD002FFFFFFFFFF; - ans = 64'hFFD002FFFFFFFFFF; + x = 64'h8000000000000407; + y = 64'hBFDFFFFFFFFFFEE0; + z = 64'hBFBF0000000FFFFF; + ans = 64'hBFBF0000000FFFFF; rn = 1; rz = 0; rm = 0; @@ -41538,12 +135115,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1778361\n"); + $fwrite(fp,"1764635\n"); end - x = 64'h3FFFFF7EFFFFFFFF; - y = 64'h380FFFFF001FFFFF; - z = 64'hBFF0080000800000; - ans = 64'hBFF0080000800000; + x = 64'h544A3DA4E3B766A1; + y = 64'h4000000000000001; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h545A3DA4E3B766A3; rn = 1; rz = 0; rm = 0; @@ -41585,12 +135162,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1780375\n"); + $fwrite(fp,"1765249\n"); end x = 64'h4000000000000001; - y = 64'h8010000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + y = 64'h46CAC970B49DD3AD; + z = 64'hC0AFFFFFFFFFE00F; + ans = 64'h46DAC970B49DD3AF; rn = 1; rz = 0; rm = 0; @@ -41632,12 +135209,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1782389\n"); + $fwrite(fp,"1765863\n"); end - x = 64'h800F00FFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - z = 64'hBF4DDFFFFFFFFFFF; - ans = 64'hBF4DDFFFFFFFFFFF; + x = 64'h8000000000020000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h41FFFFFFFC00FFFF; + ans = 64'h41FFFFFFFC00FFFF; rn = 1; rz = 0; rm = 0; @@ -41679,59 +135256,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1784403\n"); - end - x = 64'h3EFFFFFFFE000040; - y = 64'hBC1000000000207F; - z = 64'h40EFFFFFFFFDC000; - ans = 64'h40EFFFFFFFFDC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1786417\n"); + $fwrite(fp,"1766477\n"); end x = 64'h4000000000000001; - y = 64'hBFD0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + y = 64'hB7EFFFE001FFFFFF; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hB7FFFFE002000001; rn = 1; rz = 0; rm = 0; @@ -41773,12 +135303,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1788431\n"); + $fwrite(fp,"1767091\n"); end - x = 64'hC3CFFFFFFDFFEFFF; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hBFC0000003FFBFFF; - ans = 64'h43BFFFFFFDFFEFFD; + x = 64'hC00FFFFC0000001F; + y = 64'h7FF00FFFFFFFBFFF; + z = 64'hC08FFF7FFFFFFFFA; + ans = 64'h7FF80FFFFFFFBFFF; rn = 1; rz = 0; rm = 0; @@ -41820,59 +135350,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1790445\n"); - end - x = 64'h402000000011FFFE; - y = 64'h802FFFFFFFFFFFFF; - z = 64'hC00FFFE000000001; - ans = 64'hC00FFFE000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1792459\n"); + $fwrite(fp,"1767705\n"); end x = 64'h4000000000000001; - y = 64'hBFF0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC000000000000001; + y = 64'h4010000000000001; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h4020000000000002; rn = 1; rz = 0; rm = 0; @@ -41914,247 +135397,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1794473\n"); + $fwrite(fp,"1768319\n"); end - x = 64'h3F2FFFDDFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hC1E00000001003FE; - ans = 64'hC1E00000001007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1796487\n"); - end - x = 64'hC3F46EB7D64DB1F9; - y = 64'hC3D54F7FFD12E189; - z = 64'h7FF07FFFFFFFFFDF; - ans = 64'h7FF87FFFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1798501\n"); - end - x = 64'h4000000000000001; - y = 64'hC010000000000000; - z = 64'h3FF0000000000001; - ans = 64'hC01C000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1800515\n"); - end - x = 64'h002FFFFBFDFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'hC1CFFFFF7FF7FFFF; - ans = 64'hC1CFFFFF7FF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1802529\n"); - end - x = 64'h37EFFFFFFFFFFF83; - y = 64'h43E3FFFFFF800000; - z = 64'h402008000001FFFF; - ans = 64'h402008000001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1804543\n"); - end - x = 64'h4000000000000001; - y = 64'hC34FFFFFFFFFFFFE; + x = 64'h37F1FFFFFFFFBFFF; + y = 64'h15EFFFFF9FFFFFFF; z = 64'hC340000000000000; - ans = 64'hC364000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -42196,11 +135444,340 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1806557\n"); + $fwrite(fp,"1768933\n"); end - x = 64'hFFD7A538500A7D7A; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hA2C407EC69F1CC61; + x = 64'h4000000000000001; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hBFF1000010000000; + ans = 64'h402DDFFFFE000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1769547\n"); + end + x = 64'h75FFFFFF80007FFE; + y = 64'hC01FFFE000008000; + z = 64'h41F3FFFFFFFFEFFF; + ans = 64'hF62FFFDF80017FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1770161\n"); + end + x = 64'hB7EFFFC00000FFFF; + y = 64'h4340000000000000; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1770775\n"); + end + x = 64'h4000000000000001; + y = 64'hC00FF00000008000; + z = 64'h4010000001000000; + ans = 64'hC00FDFFFFE010004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1771389\n"); + end + x = 64'h7FF237D206D36360; + y = 64'h4340000000000001; + z = 64'hC3C7716C2259F813; + ans = 64'h7FFA37D206D36360; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1772003\n"); + end + x = 64'h4000000000000001; + y = 64'hC3C0FFDFFFFFFFFF; + z = 64'h8000000000000000; + ans = 64'hC3D0FFE000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1772617\n"); + end + x = 64'h414A3DD5DE82898B; + y = 64'h402F7EFFFFFFFFFE; + z = 64'h3CAFFEC000000000; + ans = 64'h4189D40C98598B4F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1773231\n"); + end + x = 64'h4000000000000001; + y = 64'h7FE0000000000000; + z = 64'h0010000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -42243,12 +135820,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1808571\n"); + $fwrite(fp,"1773845\n"); end - x = 64'h3FD0005FFFFFFFFE; - y = 64'hC3E411C0691B2909; - z = 64'hC34FFFFFF81FFFFF; - ans = 64'hC3C43238D395BFA9; + x = 64'h3FD20000FFFFFFFF; + y = 64'hBEE000000000F7FE; + z = 64'hC010000000000001; + ans = 64'hC010000090000801; rn = 1; rz = 0; rm = 0; @@ -42290,11 +135867,340 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1810585\n"); + $fwrite(fp,"1774459\n"); end x = 64'h4000000000000001; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'h10D0000008000080; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1775073\n"); + end + x = 64'h3E5FFF7FFFFFFFDE; + y = 64'h40AFFFFEFE000000; + z = 64'hBFD000000000000B; + ans = 64'hBFCFFC0010203F95; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1775687\n"); + end + x = 64'hBFE050C5935F9B62; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h3FD0000000000001; + ans = 64'hFFE050C5935F9B61; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1776301\n"); + end + x = 64'h4000000000000001; + y = 64'h47FFFFFFFF7FFFEF; + z = 64'h6FF001FFFFFFFFFA; + ans = 64'h6FF001FFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1776915\n"); + end + x = 64'hD7400007FFFFFFF7; + y = 64'h7FF0000000000000; + z = 64'h46200000017FFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1777529\n"); + end + x = 64'h4000000000000001; + y = 64'h402FFFFFFFFFFFD0; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1778143\n"); + end + x = 64'h3FBFFFF7FFFFFFFA; + y = 64'hBF8FFFFF3FFFFFFF; + z = 64'hC34800000000001F; + ans = 64'hC34800000000001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1778757\n"); + end + x = 64'h4000000000000001; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h0000000000000001; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -42337,12 +136243,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1812599\n"); + $fwrite(fp,"1779371\n"); end - x = 64'hC3D02003FFFFFFFE; - y = 64'h000FFFFFFFFFFFFF; - z = 64'h415FFFFFEFFE0000; - ans = 64'h415FFFFFEFFE0000; + x = 64'hC34FFFEFFFFFF7FE; + y = 64'hC000000000808000; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'h435FFFF00100F77C; rn = 1; rz = 0; rm = 0; @@ -42384,12 +136290,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1814613\n"); + $fwrite(fp,"1779985\n"); end - x = 64'hC1C01F7FFFFFFFFF; - y = 64'hC0CBFFFFF8000000; - z = 64'hBFE0000002000004; - ans = 64'h429C371FF7F03DFE; + x = 64'h4000000000000001; + y = 64'h8000000000000000; + z = 64'hBFEF62D1FFBD4AF4; + ans = 64'hBFEF62D1FFBD4AF4; rn = 1; rz = 0; rm = 0; @@ -42431,10 +136337,57 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1816627\n"); + $fwrite(fp,"1780599\n"); end - x = 64'h400FFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFE; + x = 64'h43F64D8FB8BB1136; + y = 64'hC49E1FFFFFFFFFFF; + z = 64'hC8000002003FFFFF; + ans = 64'hC8A503044D682B33; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1781213\n"); + end + x = 64'hC0F0000000000407; + y = 64'h800FFFFFFFFFFFFF; z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; @@ -42478,12 +136431,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1818641\n"); + $fwrite(fp,"1781827\n"); end - x = 64'hBFF73733471D9EB9; - y = 64'h3CA0000000000001; - z = 64'h47E000000FFFBFFF; - ans = 64'h47E000000FFFBFFF; + x = 64'h4000000000000001; + y = 64'hC02744F10D0CD258; + z = 64'h80276B5120A17EE2; + ans = 64'hC03744F10D0CD259; rn = 1; rz = 0; rm = 0; @@ -42525,12 +136478,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1820655\n"); + $fwrite(fp,"1782441\n"); end - x = 64'hB81FFFFFFFFF0FFE; - y = 64'hC3DFFF0000002000; - z = 64'h801C000003FFFFFE; - ans = 64'h3C0FFEFFFFFF3006; + x = 64'hBFF0002000000000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h415FFFFFE0000010; + ans = 64'h415FFFFFE0000010; rn = 1; rz = 0; rm = 0; @@ -42572,12 +136525,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1822669\n"); + $fwrite(fp,"1783055\n"); end - x = 64'h400FFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'h3FEFFFFFFFFFFFFA; + x = 64'h4000000000000001; + y = 64'hC022000080000000; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -42619,12 +136572,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1824683\n"); + $fwrite(fp,"1783669\n"); end - x = 64'hC1C0000000000FDE; - y = 64'h3FE0000000000001; - z = 64'h41D4CBFF08B3D9B1; - ans = 64'h41D0CBFF08B3D5B9; + x = 64'hC02FFFF800000006; + y = 64'h40C0000010000FFF; + z = 64'hC01FFFFF8003FFFF; + ans = 64'hC100003C0FFF0C0A; rn = 1; rz = 0; rm = 0; @@ -42666,12 +136619,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1826697\n"); + $fwrite(fp,"1784283\n"); end - x = 64'hB8D3FFFFFF000000; - y = 64'hC3D5607787B731DA; - z = 64'hFFDFFFFFFFFFFFFE; - ans = 64'hFFDFFFFFFFFFFFFE; + x = 64'h4000000000000001; + y = 64'h8010000000000001; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -42713,12 +136666,717 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1828711\n"); + $fwrite(fp,"1784897\n"); end - x = 64'h400FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; + x = 64'hB7F800B345BCBFC9; + y = 64'h7FE9C88F81D7641E; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hF7F356FC1374D3A5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1785511\n"); + end + x = 64'h4000000000000001; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h40A001FFFE000000; + ans = 64'h40A001FFFE000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1786125\n"); + end + x = 64'h3810010400000000; + y = 64'h800A307BC417CC79; + z = 64'h412D6D16F2C3A035; + ans = 64'h412D6D16F2C3A035; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1786739\n"); + end + x = 64'hBFE01003FFFFFFFF; + y = 64'hBCA0000000000001; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h3C90100400000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1787353\n"); + end + x = 64'h4000000000000001; + y = 64'hC3C000000001FF7F; + z = 64'h442FFFFF00000FFF; + ans = 64'h442F7FFF00000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1787967\n"); + end + x = 64'hC3E0000007FDFFFE; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hD8896E54EF85B595; + ans = 64'hD8896E54EF85B595; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1788581\n"); + end + x = 64'h4000000000000001; + y = 64'hBFC4000000004000; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1789195\n"); + end + x = 64'h801003FFFFFFFFFB; + y = 64'hC02FFBFF00000000; + z = 64'hBC64A4C6EF2A4F02; + ans = 64'hBC64A4C6EF2A4F02; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1789809\n"); + end + x = 64'h4000000000000001; + y = 64'hBFD0000000000000; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1790423\n"); + end + x = 64'h3FC2D2609C21B45C; + y = 64'h41DFFFFFFFC0FFFE; + z = 64'hBFF0000000000000; + ans = 64'h41B2D2609AFCA62D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1791037\n"); + end + x = 64'h4000000000000001; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC7F015AE3F3AD1AC; + ans = 64'hC7F015AE3F3AD1AC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1791651\n"); + end + x = 64'h802FF80000003FFE; + y = 64'h3F20000800003FFE; + z = 64'h3F6423F1E5D3FBF4; + ans = 64'h3F6423F1E5D3FBF4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1792265\n"); + end + x = 64'h3FC1E7598F9CD086; + y = 64'hBFE0000000000000; + z = 64'h0010000000000000; + ans = 64'hBFB1E7598F9CD086; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1792879\n"); + end + x = 64'h4000000000000001; + y = 64'h3FE003FFFF800000; + z = 64'hC01DFFEFFFFFFFFF; + ans = 64'hC019FEF0001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1793493\n"); + end + x = 64'hC000002FFFFFFFFF; + y = 64'hBFE0000000000001; + z = 64'hB7F000DFFFFFFFFE; + ans = 64'h3FF0003000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1794107\n"); + end + x = 64'h4000000000000001; + y = 64'hBFA0000000000FFB; z = 64'h4340000000000000; - ans = 64'h4340000000000004; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -42760,12 +137418,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1830725\n"); + $fwrite(fp,"1794721\n"); end - x = 64'hA2BF875A03F685CD; - y = 64'h4000000000000000; - z = 64'hC34FC0000000001F; - ans = 64'hC34FC0000000001F; + x = 64'hC03DC1C014713559; + y = 64'hB7FFFFFFFC002000; + z = 64'h3F9FFFEFFFDFFFFE; + ans = 64'h3F9FFFEFFFDFFFFE; rn = 1; rz = 0; rm = 0; @@ -42807,12 +137465,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1832739\n"); + $fwrite(fp,"1795335\n"); end - x = 64'h43FFFF000001FFFE; - y = 64'h3F4FFFFFFFFF3FFF; - z = 64'h800FFEFFFFFFFEFF; - ans = 64'h435FFF0000014003; + x = 64'h4000000000000001; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; rn = 1; rz = 0; rm = 0; @@ -42854,11 +137512,1421 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1834753\n"); + $fwrite(fp,"1795949\n"); end - x = 64'h400FFFFFFFFFFFFF; - y = 64'h4010000000000001; - z = 64'hFFFFFFFFFFFFFFFE; + x = 64'h01F748C86FB03473; + y = 64'hC7FB8788D6F9E4E6; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1796563\n"); + end + x = 64'h4000000000000001; + y = 64'hBFF0000000000001; + z = 64'h3F5F800000040000; + ans = 64'hBFFFF81FFFFFFF04; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1797177\n"); + end + x = 64'hBCA00000EFFFFFFF; + y = 64'h43C400003FFFFFFF; + z = 64'h3CA00007FFFFC000; + ans = 64'hC07400016C0003BE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1797791\n"); + end + x = 64'hC1F3FFFFFFFFFFE0; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h0000000000000001; + ans = 64'h4203FFFFFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1798405\n"); + end + x = 64'h4000000000000001; + y = 64'h43DF000007FFFFFE; + z = 64'h40100008FFFFFFFF; + ans = 64'h43EF000008000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1799019\n"); + end + x = 64'hC3F2E23919B19F0E; + y = 64'hC000000000000000; + z = 64'h7FE98F5A17F2E86E; + ans = 64'h7FE98F5A17F2E86E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1799633\n"); + end + x = 64'h4000000000000001; + y = 64'h41E609ACC408B524; + z = 64'h4010000000000001; + ans = 64'h41F609ACC448B525; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1800247\n"); + end + x = 64'h4080001003FFFFFE; + y = 64'hB81FFFF800080000; + z = 64'h40D1000000800000; + ans = 64'h40D1000000800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1800861\n"); + end + x = 64'h4000000000000001; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC340000000000001; + ans = 64'hC340000000000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1801475\n"); + end + x = 64'h8017FF8000000000; + y = 64'h747FFFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1802089\n"); + end + x = 64'h4000000000000001; + y = 64'hC010000000000000; + z = 64'hBFEFFFFFFFFFFFE4; + ans = 64'hC021FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1802703\n"); + end + x = 64'hC07000000100001F; + y = 64'hC0E4D4E49ACE0434; + z = 64'hBFCFFFFFDFFFFF80; + ans = 64'h4164D4E4941B52AE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1803317\n"); + end + x = 64'h46B0027FFFFFFFFF; + y = 64'hC010000000000001; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1803931\n"); + end + x = 64'h4000000000000001; + y = 64'hBFD11F7A827D1E2E; + z = 64'h4005DD80C016477D; + ans = 64'h400195A21F76FFF1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1804545\n"); + end + x = 64'hFFFE280615241B91; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h79AFFF03FFFFFFFE; + ans = 64'hFFFE280615241B91; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1805159\n"); + end + x = 64'h4000000000000001; + y = 64'hC7EBFFFE00000000; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'hC7FBFFFE00000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1805773\n"); + end + x = 64'hBE27ECA300A3042F; + y = 64'hFFD60AAFC2B75EE4; + z = 64'h3E703FFFFFFEFFFF; + ans = 64'h7E107AAD6B0F65B7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1806387\n"); + end + x = 64'h4000000000000001; + y = 64'hC340000000000001; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC350000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1807001\n"); + end + x = 64'h402FF000001FFFFF; + y = 64'hCCAFF1B2E8DEC363; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hCCEFE1BA0F8A45B3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1807615\n"); + end + x = 64'h4000000000000001; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h37E007FFFFFFFBFF; + ans = 64'hC360000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1808229\n"); + end + x = 64'hBFBFEFFFFFFFFFFB; + y = 64'h117FFE000003FFFF; + z = 64'hC0107437118816CB; + ans = 64'hC0107437118816CB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1808843\n"); + end + x = 64'hF4D0000400000FFE; + y = 64'hFFE0000000000000; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1809457\n"); + end + x = 64'h4000000000000001; + y = 64'hCA0FFFFFFDFFFBFF; + z = 64'h43E0000200000002; + ans = 64'hCA1FFFFFFDFFFC01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1810071\n"); + end + x = 64'hB7EF275E3109EBEA; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hD600000FFFFFFFBF; + ans = 64'h77EF275E3109EBE9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1810685\n"); + end + x = 64'h4000000000000001; + y = 64'h41F07FE000000000; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h42007FE000100001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1811299\n"); + end + x = 64'hFFFFFFFFFFF7FFFA; + y = 64'h361FFFFFFFF0003E; + z = 64'hBFCDE782F05F6E29; + ans = 64'hFFFFFFFFFFF7FFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1811913\n"); + end + x = 64'h4000000000000001; + y = 64'hFFF0000000000000; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1812527\n"); + end + x = 64'hBF83BAA79E85EC1A; + y = 64'h3FBFFFFFFFE003FE; + z = 64'hBCA0000000000000; + ans = 64'hBF53BAA79E7235E8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1813141\n"); + end + x = 64'h4000000000000001; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h7FD8000000FFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1813755\n"); + end + x = 64'hBFEFF5F3E00E51FC; + y = 64'h381AA9A05DB030CE; + z = 64'hC01FFFFFDFFFFF7F; + ans = 64'hC01FFFFFDFFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1814369\n"); + end + x = 64'hB800001FFF7FFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hFFE0000000000000; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -42901,106 +138969,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1836767\n"); - end - x = 64'hC03F8000000000FE; - y = 64'h4340000000000000; - z = 64'hC1C0040000000007; - ans = 64'hC38F8000010040FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1838781\n"); - end - x = 64'hBFCFFFFFDFFFF7FF; - y = 64'hBCF0000400003FFE; - z = 64'hC0689FA5E30DF9AB; - ans = 64'hC0689FA5E30DF9AB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1840795\n"); + $fwrite(fp,"1814983\n"); end x = 64'h400FFFFFFFFFFFFF; - y = 64'h7FE0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; + y = 64'h7EEA3D84C3E981AE; + z = 64'h3FF0000000001F7F; + ans = 64'h7F0A3D84C3E981AD; rn = 1; rz = 0; rm = 0; @@ -43042,12 +139016,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1842809\n"); + $fwrite(fp,"1815597\n"); end - x = 64'h41D1F471DB7E29ED; - y = 64'h7FF0000000000000; - z = 64'h884400000000FFFF; - ans = 64'h7FF0000000000000; + x = 64'hBFEFFFFFFFEFFFFC; + y = 64'h0000000000000001; + z = 64'h41B0001800000000; + ans = 64'h41B0001800000000; rn = 1; rz = 0; rm = 0; @@ -43089,58 +139063,951 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1844823\n"); - end - x = 64'hDF800007FFFFFFFF; - y = 64'hBE700000080001FE; - z = 64'hC7EFFFF0000000FF; - ans = 64'h5E000008080005FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1846837\n"); + $fwrite(fp,"1816211\n"); end x = 64'h400FFFFFFFFFFFFF; - y = 64'h8000000000000001; - z = 64'h3FF0000000000001; + y = 64'h37EFFFFFE0FFFFFF; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1816825\n"); + end + x = 64'h5BE66EEA72E09608; + y = 64'h4346A605EF720221; + z = 64'h001FFFFF03FFFFFE; + ans = 64'h5F3FC14970BE939C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1817439\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1818053\n"); + end + x = 64'hD0C00FFFEFFFFFFE; + y = 64'h434FFFEFFFFFFBFE; + z = 64'h8010000000000001; + ans = 64'hD4200FF7E80005FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1818667\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h0010000000000001; + z = 64'h43D844324AC65C66; + ans = 64'h43D844324AC65C66; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1819281\n"); + end + x = 64'hC03A841F0672CCEA; + y = 64'hBFFFEFFFFFDFFFFE; + z = 64'hC10E000200000000; + ans = 64'hC10DFE5A923092AF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1819895\n"); + end + x = 64'h91C0000004008000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1820509\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hB81002003FFFFFFF; + z = 64'h2C58001FFFFFFFFF; + ans = 64'hB83002003FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1821123\n"); + end + x = 64'h3CAFEFFFFFFFFFE0; + y = 64'h3CA0000000000000; + z = 64'h3040000000000000; + ans = 64'h395FEFFFFFFFFFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1821737\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hB7EFFFFFE0200000; + z = 64'h3FE0000000000001; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1822351\n"); + end + x = 64'hC80FFFFFE0000002; + y = 64'hBF0B6637E256754F; + z = 64'h37F66727FC897D25; + ans = 64'h472B6637C6F03D6E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1822965\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFEFFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1823579\n"); + end + x = 64'h415F800000000100; + y = 64'hC3E0000FFF000000; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'hC54F801F7E080100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1824193\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h3FD0000000000000; + z = 64'h37EBFFFFFFFFFFFC; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1824807\n"); + end + x = 64'h3FE4116E93E56F17; + y = 64'h3FCF7FFFF8000000; + z = 64'hC0201007FFFFFFFE; + ans = 64'hC01F8206B95B740E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1825421\n"); + end + x = 64'h358000007FFFDFFF; + y = 64'h3FD0000000000001; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1826035\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC1CFFFF000000040; + z = 64'h7FDECC2967860F7E; + ans = 64'h7FDECC2967860F7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1826649\n"); + end + x = 64'h3810000003FFFFFD; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3FC00000001FFE00; + ans = 64'h3FC00000001FFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1827263\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC62FFFF804000000; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'hC64FFFF803FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1827877\n"); + end + x = 64'hBFF81F36391021FB; + y = 64'h4050004FFFFFFFFF; + z = 64'h6C0FFF807FFFFFFF; + ans = 64'h6C0FFF807FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1828491\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h3FE0000000000001; + z = 64'hBFEFFFFFFFFFFFFF; ans = 64'h3FF0000000000001; rn = 1; rz = 0; @@ -43183,12 +140050,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1848851\n"); + $fwrite(fp,"1829105\n"); end - x = 64'hCBE2B464D5FB92A3; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hC6DFFFFFFFFFFFFE; - ans = 64'hC6DFFFFFFFFFFFFE; + x = 64'hC020000000FBFFFE; + y = 64'h407EEFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -43230,59 +140097,1892 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1850865\n"); - end - x = 64'h4F9FFFFF000003FF; - y = 64'h41CF8000FFFFFFFE; - z = 64'h4047FFFFFBFFFFFF; - ans = 64'h517F800003FFFBED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1852879\n"); + $fwrite(fp,"1829719\n"); end x = 64'h400FFFFFFFFFFFFF; - y = 64'hBCA0000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h6BD0400000010000; + ans = 64'h6BD0400000010000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1830333\n"); + end + x = 64'h4D069B23F868B6DD; + y = 64'hC2600020000FFFFF; + z = 64'h0022F3A10B222F4A; + ans = 64'hCF769B512EC742D1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1830947\n"); + end + x = 64'h372FFFFFFFFE007F; + y = 64'h3FF0000000000000; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1831561\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC3EFFFFF7FFFFEFF; + z = 64'hC0E2E2D8FDDA0A73; + ans = 64'hC40FFFFF7FFFFF03; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1832175\n"); + end + x = 64'h43C00000007F7FFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hBFE20FF482B66D99; + ans = 64'h43D00000007F7FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1832789\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC3EA35D616039DF4; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'hC40A35D616039DF3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1833403\n"); + end + x = 64'hFFEFFFFEFFEFFFFF; + y = 64'hBFDC7B63D40DC944; + z = 64'h4460040000000004; + ans = 64'h7FDC7B62F0246CF1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1834017\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h4000000000000000; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h401DFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1834631\n"); + end + x = 64'h402FFFFFFFFFFEFE; + y = 64'h4000007FFFF80000; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1835245\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h800C6068B41C7BB7; + ans = 64'h402FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1835859\n"); + end + x = 64'h373CE9EB12A75385; + y = 64'hEAC0002007FFFFFE; + z = 64'hAC7007FFBFFFFFFF; + ans = 64'hE20CEA24F4F26E59; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1836473\n"); + end + x = 64'h2BB0800000000800; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1837087\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h4B7FFFFFFFFFF03E; + z = 64'h3CE080000000FFFF; + ans = 64'h4B9FFFFFFFFFF03D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1837701\n"); + end + x = 64'h4530037FFFFFFFFE; + y = 64'h4010000000000001; + z = 64'hBF700200000001FF; + ans = 64'h4550037FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1838315\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hFFEF0000003FFFFF; + z = 64'h3CA0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1838929\n"); + end + x = 64'h3810000001FFFBFF; + y = 64'h57E000F800000000; + z = 64'h403000000000C000; + ans = 64'h500000F802001AFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1839543\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hBFD0000000000000; + ans = 64'h403FBFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1840157\n"); + end + x = 64'h3FCFFFFFFFFF00FE; + y = 64'hC34000FFFFFFFFFD; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1840771\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h4340000000000001; + z = 64'h7FFFFFFFFFFFFFDC; + ans = 64'h7FFFFFFFFFFFFFDC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1841385\n"); + end + x = 64'hC34AA4AD5429CD0E; + y = 64'h002FFFFC00FFFFFE; + z = 64'h0010100000200000; + ans = 64'h838AA4AA006947F2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1841999\n"); + end + x = 64'hC34FFFF800000010; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hC6AFFFF80000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1842613\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h638FFFFFFAFFFFFF; + z = 64'hC1CFFFFFF8007FFE; + ans = 64'h63AFFFFFFAFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1843227\n"); + end + x = 64'hB7FF7FFFFFFFF000; + y = 64'h7FE0000000000000; + z = 64'h78B01FFFEFFFFFFF; + ans = 64'h78B01F03F0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1843841\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hBFCFFFFF04000000; + z = 64'h0010000000000001; + ans = 64'hBFEFFFFF03FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1844455\n"); + end + x = 64'h3806DE6D558BFE8E; + y = 64'hC06FB4D241F29CCB; + z = 64'h3C7C9728EFA05491; + ans = 64'h3C7C9728EFA05491; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1845069\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hBCA0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1845683\n"); + end + x = 64'hBFD0000FFF7FFFFE; + y = 64'h5500001FFFFFBFFF; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'hD4E0002FFF9FBEFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1846297\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h7FF0000000000000; + z = 64'h37EB9B5ABEC6C2F2; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1846911\n"); + end + x = 64'h7FD00005FFFFFFFE; + y = 64'h41FFFFFFFFFFFFFF; + z = 64'h43DFFFF7FFFFFFBF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1847525\n"); + end + x = 64'hC1EFFFFFFF81FFFE; + y = 64'h7FF0000000000001; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1848139\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h7FF00000000107FF; + z = 64'hC01000FFFFFFFF00; + ans = 64'h7FF80000000107FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1848753\n"); + end + x = 64'hC34DFFFFFFF80000; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h40B0003FFFFFDFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1849367\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h7FDFFEEFFFFFFFFF; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1849981\n"); + end + x = 64'h4800000010000040; + y = 64'h400ED4F0320ECE0D; + z = 64'h4345D3E889C98140; + ans = 64'h481ED4F050E3BEBA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1850595\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h8000000000000001; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h8020000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1851209\n"); + end + x = 64'hFFE004000000001F; + y = 64'hD01D0009A1468219; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1851823\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h7F20001040000000; + ans = 64'h7F20001040000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1852437\n"); + end + x = 64'hB80F1FFFFFFFFFFE; + y = 64'h3F8000000007FDFF; + z = 64'hB7F000FFFFFFDFFF; + ans = 64'hB7F07D8000001E2F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1853051\n"); + end + x = 64'hB8000000000017FF; + y = 64'h8010000000000000; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1853665\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC1EFFFF900000000; + z = 64'h3FF9BEB5ED8496DD; + ans = 64'hC20FFFF8FFF320A4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1854279\n"); + end + x = 64'h380FC00003FFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h3FC54CA808F073E0; + ans = 64'h3FC54CA808F073E0; rn = 1; rz = 0; rm = 0; @@ -43326,666 +142026,8 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"1854893\n"); end - x = 64'h3FE007FFBFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h3FF207FFFFFFFFFE; - ans = 64'h3FF207FFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1856907\n"); - end - x = 64'hC02FFFFFBFFFFFEF; - y = 64'h8003FFFFFFFFF800; - z = 64'hF00FFFFFFDFC0000; - ans = 64'hF00FFFFFFDFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1858921\n"); - end x = 64'h400FFFFFFFFFFFFF; - y = 64'hBFE0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1860935\n"); - end - x = 64'hC03100000001FFFF; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'h414FFFFF800FFFFF; - ans = 64'h4150000400080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1862949\n"); - end - x = 64'h402FFFFFE0040000; - y = 64'hC3EA62ADD43FE399; - z = 64'hC3D000001E000000; - ans = 64'hC42AE2ADBAD0821A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1864963\n"); - end - x = 64'h400FFFFFFFFFFFFF; - y = 64'hC000000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1866977\n"); - end - x = 64'h4050000090000000; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h40BFFFFFFFFFBFFE; - ans = 64'h40BEFFFFF6FFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1868991\n"); - end - x = 64'h400FFFFFFF7FFFF7; - y = 64'h402FFFFFFE002000; - z = 64'h47EC7E6897273689; - ans = 64'h47EC7E6897273689; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1871005\n"); - end - x = 64'h400FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hC0407FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1873019\n"); - end - x = 64'hC0377BBF63A456E8; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hC0BFFFFFFF7FEFFF; - ans = 64'h43977BBF63A45667; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1875033\n"); - end - x = 64'h7FEFFF7C00000000; - y = 64'h407007DFFFFFFFFF; - z = 64'hC340000800003FFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1877047\n"); - end - x = 64'h400FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1879061\n"); - end - x = 64'h8D7D390A1C93061B; - y = 64'hFFF0000000000001; - z = 64'h912FF83FFFFFFFFE; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1881075\n"); - end - x = 64'hFFF0200003FFFFFE; - y = 64'h406B558929B9440F; - z = 64'h38101000FFFFFFFF; - ans = 64'hFFF8200003FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1883089\n"); - end - x = 64'h400FFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFF; + y = 64'h381F7FBFFFFFFFFF; z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; @@ -44029,12 +142071,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1885103\n"); + $fwrite(fp,"1855507\n"); end - x = 64'h7FFD52F603F067DD; - y = 64'h0010000000000001; - z = 64'hDCA8000000001FFF; - ans = 64'h7FFD52F603F067DD; + x = 64'h375FFFDFFFF7FFFF; + y = 64'hC3EFFFFFFFBFFFF6; + z = 64'h38EF7F0000000000; + ans = 64'hBB5FFFDFFFB7C137; rn = 1; rz = 0; rm = 0; @@ -44076,12 +142118,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1887117\n"); + $fwrite(fp,"1856121\n"); end - x = 64'h3A10800004000000; - y = 64'h800F800100000000; - z = 64'hBD7FFFFFFDFFFFC0; - ans = 64'hBD7FFFFFFDFFFFC0; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hBCA0000000000000; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hBCBFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -44123,12 +142165,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1889131\n"); + $fwrite(fp,"1856735\n"); end - x = 64'h400FFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3CC7FFFFFFFFFFFD; + x = 64'hBFE0000000000000; + y = 64'h40303FFFDFFFFFFE; + z = 64'h4010000000000000; + ans = 64'hC0107FFFBFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -44170,12 +142212,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1891145\n"); + $fwrite(fp,"1857349\n"); end - x = 64'h3FF0000007C00000; - y = 64'h3FD0000000000001; - z = 64'hC02FFFFFFFFF3FFF; - ans = 64'hC02F7FFFFFC13FFF; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hC031FFFFF7FFFFFF; + ans = 64'hC031FFFFF7FFFFFF; rn = 1; rz = 0; rm = 0; @@ -44217,12 +142259,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1893159\n"); + $fwrite(fp,"1857963\n"); end - x = 64'h1D9BEFFFFFFFFFFE; - y = 64'h8000800000000800; - z = 64'hFFE208A662F4A6B2; - ans = 64'hFFE208A662F4A6B2; + x = 64'h3E1DFFFFFFFEFFFF; + y = 64'h816FFFFF7FFFFBFE; + z = 64'h3F4FFEFFFFFFBFFE; + ans = 64'h3F4FFEFFFFFFBFFE; rn = 1; rz = 0; rm = 0; @@ -44264,12 +142306,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1895173\n"); + $fwrite(fp,"1858577\n"); end - x = 64'h400FFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h4013FFFFFFFFFFFF; + x = 64'h37FFA1D0ECBF6C4F; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; rn = 1; rz = 0; rm = 0; @@ -44311,12 +142353,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1897187\n"); + $fwrite(fp,"1859191\n"); end - x = 64'hBCDFFFFFFFFF7BFE; - y = 64'h3FF0000000000000; - z = 64'hBE200FFFFFFFFFF6; - ans = 64'hBE201000FFFFFFF6; + x = 64'h400FFFFFFFFFFFFF; + y = 64'h3810CD5B23763DB0; + z = 64'h37FDDD58B748F787; + ans = 64'h3832AB30AEEACD28; rn = 1; rz = 0; rm = 0; @@ -44358,12 +142400,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1899201\n"); + $fwrite(fp,"1859805\n"); end - x = 64'hBFF0007F00000000; - y = 64'h468FFC00000FFFFF; - z = 64'h40040072D2D248CC; - ans = 64'hC68FFCFDE050007E; + x = 64'hC1F000403FFFFFFF; + y = 64'hBFD0000000000001; + z = 64'h43400001FFFF0000; + ans = 64'h434000021FFF8080; rn = 1; rz = 0; rm = 0; @@ -44405,12 +142447,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1901215\n"); + $fwrite(fp,"1860419\n"); end - x = 64'h400FFFFFFFFFFFFE; - y = 64'h4000000000000001; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFF8; + x = 64'h400FFFFFFFFFFFFF; + y = 64'h7122319B49C3C14C; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -44452,12 +142494,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1903229\n"); + $fwrite(fp,"1861033\n"); end - x = 64'hBCA1000000010000; - y = 64'h4010000000000000; - z = 64'h37F087FFFFFFFFFF; - ans = 64'hBCC1000000010000; + x = 64'hBF100FFFF7FFFFFF; + y = 64'hC00FFFC0000003FE; + z = 64'hA5AFFFFE0001FFFE; + ans = 64'h3F300FDFD8001200; rn = 1; rz = 0; rm = 0; @@ -44499,12 +142541,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1905243\n"); + $fwrite(fp,"1861647\n"); end - x = 64'h1200000FFFFFFFEE; - y = 64'h5EE7632438177A2D; - z = 64'hC2B0000003E00000; - ans = 64'hC2B0000003E00000; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h8000000000000000; + ans = 64'hBFFFFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -44546,12 +142588,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1907257\n"); + $fwrite(fp,"1862261\n"); end - x = 64'h400FFFFFFFFFFFFE; - y = 64'h4340000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + x = 64'h3FFE000000000100; + y = 64'h0000004007FFFFFE; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; rn = 1; rz = 0; rm = 0; @@ -44593,11 +142635,58 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1909271\n"); + $fwrite(fp,"1862875\n"); end - x = 64'h41D004000007FFFF; - y = 64'h7FE0000000000000; - z = 64'hFFE0080000000004; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hBFE0000000000001; + z = 64'h403FFFFFFC000080; + ans = 64'h403DFFFFFC000080; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1863489\n"); + end + x = 64'h417063B4BEBF8A2B; + y = 64'h7FDFFFFFFFFFF004; + z = 64'hB990040080000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -44640,12 +142729,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1911285\n"); + $fwrite(fp,"1864103\n"); end - x = 64'hC1D0000007FFFEFF; - y = 64'hC07FFFFFFF03FFFF; - z = 64'hBFDFFFFFFFFE7FFE; - ans = 64'h426000000781EEFE; + x = 64'hB7F8BB8D71BC61CF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; rn = 1; rz = 0; rm = 0; @@ -44687,11 +142776,199 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1913299\n"); + $fwrite(fp,"1864717\n"); end - x = 64'h400FFFFFFFFFFFFE; - y = 64'h7FF0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC1EFFFFBFDFFFFFF; + z = 64'hC3E00010003FFFFE; + ans = 64'hC3E0001000BFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1865331\n"); + end + x = 64'hBFDFFFFFFFFDFFFF; + y = 64'hBFF0000000000000; + z = 64'hBFCFFFFE7FFFFFFF; + ans = 64'h3FD00000BFFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1865945\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hBFB000000FFEFFFF; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1866559\n"); + end + x = 64'hC15FFFFF7FFFFFBF; + y = 64'h3FDFFFFFFFFE0004; + z = 64'h11EFDFFFFFFF7FFF; + ans = 64'hC14FFFFF7FFDFFC3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1867173\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h7FF0000000000001; ans = 64'h7FF8000000000001; rn = 1; rz = 0; @@ -44734,12 +143011,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1915313\n"); + $fwrite(fp,"1867787\n"); end - x = 64'hBFE00000040007FE; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'h47FB9BC41BFD4FB5; - ans = 64'h7FFFFFFFFFFFFFFE; + x = 64'hCF8FFFBFFFFFFFEF; + y = 64'h3F3A0774EB65EC56; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'hCEDA0740DC7C157C; rn = 1; rz = 0; rm = 0; @@ -44781,12 +143058,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1917327\n"); + $fwrite(fp,"1868401\n"); end - x = 64'hC013A5CD955A8ECA; - y = 64'h3E007FFFFF7FFFFF; - z = 64'h3B0059C22188F0F5; - ans = 64'hBE2442FC016834CE; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC000000000000000; + z = 64'hB8AB26A99C3445EA; + ans = 64'hC01FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -44828,12 +143105,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1919341\n"); + $fwrite(fp,"1869015\n"); end - x = 64'h400FFFFFFFFFFFFE; - y = 64'h8010000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; + x = 64'h3DF851C97AE489ED; + y = 64'h406F7FFFEFFFFFFF; + z = 64'h80202003FFFFFFFF; + ans = 64'h3E77F08248D01307; rn = 1; rz = 0; rm = 0; @@ -44875,12 +143152,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1921355\n"); + $fwrite(fp,"1869629\n"); end - x = 64'hC02FFBFFFFFFFBFF; - y = 64'h801FFFFFFFFFFFFE; - z = 64'hC7EFF7FFFBFFFFFF; - ans = 64'hC7EFF7FFFBFFFFFF; + x = 64'hC3C0001EFFFFFFFF; + y = 64'hC000000000000001; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h43D0001F00000000; rn = 1; rz = 0; rm = 0; @@ -44922,12 +143199,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1923369\n"); + $fwrite(fp,"1870243\n"); end - x = 64'h002FFFFF83FFFFFF; - y = 64'hC3E401FFFFFFFFFE; - z = 64'hC008DA6B71896C94; - ans = 64'hC008DA6B71896C94; + x = 64'h400FFFFFFFFFFFFF; + y = 64'h401D57E3BE3A6EEF; + z = 64'hBFEFFFFFE001FFFF; + ans = 64'h403C57E3BF3A5EEE; rn = 1; rz = 0; rm = 0; @@ -44969,294 +143246,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1925383\n"); + $fwrite(fp,"1870857\n"); end - x = 64'h400FFFFFFFFFFFFE; - y = 64'hBFD0000000000000; - z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1927397\n"); - end - x = 64'h44F00000020001FF; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hBF2DFFFFFFFDFFFE; - ans = 64'hC4E00000020001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1929411\n"); - end - x = 64'hC3440000001FFFFF; - y = 64'h4026DAC6A72B13B9; - z = 64'hC0000000003FC000; - ans = 64'hC37C917851238E33; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1931425\n"); - end - x = 64'h400FFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1933439\n"); - end - x = 64'hC030000000107FFE; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'hC3C0800000002000; - ans = 64'hC3C0800000002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1935453\n"); - end - x = 64'hF11FFC00000001FE; - y = 64'h3802000000008000; - z = 64'hBF201FFFFFFFFF7E; - ans = 64'hE931FDC00000810F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1937467\n"); - end - x = 64'h400FFFFFFFFFFFFE; + x = 64'hB20F9FFFFFFFFFFE; y = 64'hC00FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC02FFFFFFFFFFFFC; + z = 64'h3FFFFFDFFFFDFFFE; + ans = 64'h3FFFFFDFFFFDFFFE; rn = 1; rz = 0; rm = 0; @@ -45298,12 +143293,200 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1939481\n"); + $fwrite(fp,"1871471\n"); end - x = 64'h41C00000000FFFEF; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC00FFFFFBFFFFF7F; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC350000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1872085\n"); + end + x = 64'hBFEFFF9FFFFFFFFE; + y = 64'hA62000003FFFF000; + z = 64'h47EFE0007FFFFFFF; + ans = 64'h47EFE0007FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1872699\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC010000000000001; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1873313\n"); + end + x = 64'hC010000003FBFFFE; + y = 64'h403FFFFFFF0007FF; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'hC05FC00006F807FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1873927\n"); + end + x = 64'h400FFFFFFFFFFFFF; y = 64'hC01FFFFFFFFFFFFF; - z = 64'h40700007FFFBFFFE; - ans = 64'hC1EFFFFFE01FEFDD; + z = 64'hC8DF00000001FFFF; + ans = 64'hC8DF00000001FFFF; rn = 1; rz = 0; rm = 0; @@ -45345,12 +143528,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1941495\n"); + $fwrite(fp,"1874541\n"); end - x = 64'h43400FFFFFFFC000; - y = 64'hC02FFE0000004000; - z = 64'hB0E5C63EF0C86421; - ans = 64'hC3800EFEFFFFE024; + x = 64'hC297CC5006358D3A; + y = 64'hC08AE04A81A830FF; + z = 64'h7FDFFF6FFFFFFFFF; + ans = 64'h7FDFFF6FFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -45392,12 +143575,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1943509\n"); + $fwrite(fp,"1875155\n"); end - x = 64'h400FFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'hC36FFFFFFFFFFFFC; + x = 64'h3811FFFFFFFFFFEF; + y = 64'hC340000000000000; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hBB61FFFFFFFFFFEF; rn = 1; rz = 0; rm = 0; @@ -45439,857 +143622,293 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1945523\n"); + $fwrite(fp,"1875769\n"); end - x = 64'h3FDFFFFFFFFF8006; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC030100FFFFFFFFF; + z = 64'h3EC0007FFFFFFFFF; + ans = 64'hC050100FF7FFBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1876383\n"); + end + x = 64'h3FE001FFFDFFFFFE; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h3DE0020000800000; + ans = 64'hC34001FFFDFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1876997\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h43CEFFFFFFFFFFFB; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'h43EEFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1877611\n"); + end + x = 64'hFFF0000400000800; + y = 64'h41D4297AAC5A616A; + z = 64'h403FFFFFF003FFFE; + ans = 64'hFFF8000400000800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1878225\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hFFE0000000000000; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1878839\n"); + end + x = 64'h0000000FFFFFF800; + y = 64'h0740000001000000; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1879453\n"); + end + x = 64'h400FFFFFFFFFFFFF; y = 64'hFFE0000000000001; - z = 64'h400FFDFFFFFBFFFE; - ans = 64'hFFCFFFFFFFFF8008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1947537\n"); - end - x = 64'hBFE8F26BC072A863; - y = 64'hB81FFFFFFFF00000; - z = 64'h381000020FFFFFFF; - ans = 64'h38247936E8331796; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1949551\n"); - end - x = 64'h400FFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1951565\n"); - end - x = 64'h4110000FFFFFFFFF; - y = 64'h0000000000000001; - z = 64'hB250003FFEFFFFFE; - ans = 64'hB250003FFEFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1953579\n"); - end - x = 64'h43CA1D89C3DA0FFB; - y = 64'h800000000FF80000; - z = 64'hBFD000000047FFFE; - ans = 64'hBFD000000047FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1955593\n"); - end - x = 64'h4010000000000000; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1957607\n"); - end - x = 64'hB8EFFFFDFFFFF7FE; - y = 64'h3CA0000000000001; - z = 64'hC34DA4798969E536; - ans = 64'hC34DA4798969E536; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1959621\n"); - end - x = 64'h43DFFEFFFFFFFFFB; - y = 64'hC80FC00800000000; - z = 64'h4340404000000000; - ans = 64'hCBFFBF09FFBFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1961635\n"); - end - x = 64'h4010000000000000; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1963649\n"); - end - x = 64'h3D7FDFFFFC000000; - y = 64'h3FE0000000000000; - z = 64'h41E0200000003FFF; - ans = 64'h41E0200000003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1965663\n"); - end - x = 64'h000FFFFFFFFFF07F; - y = 64'h41E7FFFFFDFFFFFE; - z = 64'hC3DFFFFFFFF77FFF; - ans = 64'hC3DFFFFFFFF77FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1967677\n"); - end - x = 64'h4010000000000000; - y = 64'h3FF0000000000001; - z = 64'hBFF0000000000001; - ans = 64'h4008000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1969691\n"); - end - x = 64'h3FDFFFBFFFFFFFFA; - y = 64'h4000000000000000; - z = 64'h400080003FFFFFFF; - ans = 64'h40087FF03FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1971705\n"); - end - x = 64'h401EFFFFFFFBFFFF; - y = 64'h400C000000000FFF; - z = 64'h3FEE5F5B0DDD3442; - ans = 64'h403C12FAD86B7920; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1973719\n"); - end - x = 64'h4010000000000000; - y = 64'h4010000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1975733\n"); - end - x = 64'h381F8007FFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - z = 64'hC3FFFFFEFFFC0000; - ans = 64'hC3FFFFFEFFFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1977747\n"); - end - x = 64'h3490000000800800; - y = 64'hC47FF7FFBFFFFFFE; - z = 64'h800FC08000000000; - ans = 64'hB91FF7FFC0FFCFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1979761\n"); - end - x = 64'h4010000000000000; - y = 64'h7FE0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1981775\n"); - end - x = 64'hC1D03FFFFFFFFF80; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hC1E54BD798858720; + z = 64'hBE4F470F822B383A; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -46332,12 +143951,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1983789\n"); + $fwrite(fp,"1880067\n"); end - x = 64'hEA9F41DC9A5B6689; - y = 64'hFFE00000041FFFFE; - z = 64'hC7AD37E607EEC4B6; - ans = 64'h7FF0000000000000; + x = 64'hC3D4000FFFFFFFFF; + y = 64'hC800000000003FFC; + z = 64'h3EF3FFFFFF7FFFFF; + ans = 64'h4BE4001000004FFA; rn = 1; rz = 0; rm = 0; @@ -46379,12 +143998,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1985803\n"); + $fwrite(fp,"1880681\n"); end - x = 64'h4010000000000000; - y = 64'h8000000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; + x = 64'h00003FEFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h8000000000000000; + ans = 64'hBFAFF7FFFFFFFF7E; rn = 1; rz = 0; rm = 0; @@ -46426,12 +144045,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1987817\n"); + $fwrite(fp,"1881295\n"); end - x = 64'hC1E788895620064F; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hC00F00FFFFFFFFFE; - ans = 64'hC00F00FFFFFFFFFE; + x = 64'h400FFFFFFFFFFFFF; + y = 64'h3FCFFFFFFBFFFF7F; + z = 64'h58B4207C1CD84EB1; + ans = 64'h58B4207C1CD84EB1; rn = 1; rz = 0; rm = 0; @@ -46473,669 +144092,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1989831\n"); + $fwrite(fp,"1881909\n"); end - x = 64'h3FCFFFFFFFE00000; - y = 64'hAA26A278E9C77CA7; - z = 64'hA3A04316FDB9DFA9; - ans = 64'hAA06A278E9B0DA2E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1991845\n"); - end - x = 64'h4010000000000000; - y = 64'hBCA0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1993859\n"); - end - x = 64'hC0100010003FFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hC3D000003F7FFFFF; - ans = 64'hC3D000003F7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1995873\n"); - end - x = 64'hBFC0040FFFFFFFFF; - y = 64'h34100FFFFFEFFFFE; - z = 64'h3FC00000000000FE; - ans = 64'h3FC00000000000FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1997887\n"); - end - x = 64'h4010000000000000; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1999901\n"); - end - x = 64'hC760000001FFFFF8; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hBFCFFFFEFFFF7FFE; - ans = 64'h4760000001FFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2001915\n"); - end - x = 64'h43E000000001007F; - y = 64'h3FD2BFF6A883BA1F; - z = 64'h3FC3EFFFFFFFFFFF; - ans = 64'h43C2BFF6A884E6B3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2003929\n"); - end - x = 64'h4010000000000000; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2005943\n"); - end - x = 64'hD1680001FFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h3F8FE10000000000; - ans = 64'h51880001FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2007957\n"); - end - x = 64'h1C3FAFFFFFFFFFFE; - y = 64'h5117FFFC00000000; - z = 64'h3FBBBFFFFFFFFFFF; - ans = 64'h3FBBBFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2009971\n"); - end - x = 64'h4010000000000000; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC03FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2011985\n"); - end - x = 64'hC02000000000FFFF; - y = 64'hC340000000000001; - z = 64'h3FDF3A13972DC395; - ans = 64'h4370000000010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2013999\n"); - end - x = 64'h3E90000007FFDFFE; - y = 64'hBF9F000000FFFFFF; - z = 64'hDE78A6810C5E2943; - ans = 64'hDE78A6810C5E2943; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2016013\n"); - end - x = 64'h4010000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2018027\n"); - end - x = 64'h47F000000FFFFFEF; + x = 64'h802EA50D4C6B8C19; y = 64'hFFF0000000000001; - z = 64'h3EC212497B5FBA52; + z = 64'hBCAFAF3CE171A7BD; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -47178,12 +144139,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2020041\n"); + $fwrite(fp,"1882523\n"); end - x = 64'hC2422D50B4254ACC; - y = 64'hC98FFFFBFF7FFFFF; - z = 64'h43B00003FFFFFFFC; - ans = 64'h4BE22D4E6E327F04; + x = 64'h400FFFFFFFFFFFFF; + y = 64'h47FFFFFFC0000010; + z = 64'hC010000000000000; + ans = 64'h481FFFFFC000000F; rn = 1; rz = 0; rm = 0; @@ -47225,12 +144186,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2022055\n"); + $fwrite(fp,"1883137\n"); end - x = 64'h4010000000000001; + x = 64'h37A0020000080000; + y = 64'h4CEFFFFFFFFFFFAE; + z = 64'hFFF010003FFFFFFF; + ans = 64'hFFF810003FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1883751\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1884365\n"); + end + x = 64'h2943FFFFF8000000; + y = 64'hC7F0000003FEFFFF; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1884979\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h0000000000000000; + z = 64'h3F80800000000000; + ans = 64'h3F80800000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1885593\n"); + end + x = 64'hFFFFFFFFFF000007; + y = 64'hB7FFE00000000000; + z = 64'hBFF00007FFFFBFFF; + ans = 64'hFFFFFFFFFF000007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1886207\n"); + end + x = 64'h413EFFFFFFFFEFFE; y = 64'h000FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; rn = 1; rz = 0; rm = 0; @@ -47272,12 +144468,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2024069\n"); + $fwrite(fp,"1886821\n"); end - x = 64'hBFF8F0CC26A49147; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h4013531A0FBE0E92; + z = 64'hFFEE5ACB0C27A0DC; + ans = 64'hFFEE5ACB0C27A0DC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1887435\n"); + end + x = 64'h2A00000200001FFE; y = 64'h0010000000000000; - z = 64'hBFCFFFBFFFFFFFEF; - ans = 64'hBFCFFFBFFFFFFFEF; + z = 64'h3FEFFFFEFFFDFFFE; + ans = 64'h3FEFFFFEFFFDFFFE; rn = 1; rz = 0; rm = 0; @@ -47319,12 +144562,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2026083\n"); + $fwrite(fp,"1888049\n"); end - x = 64'h41C0007FFC000000; - y = 64'h3C4FF80000001FFF; - z = 64'hC49EF96D79F85B02; - ans = 64'hC49EF96D79F85B02; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC1C1FFFFFFFFFC00; + z = 64'hC000000000000001; + ans = 64'hC1E20000003FFBFF; rn = 1; rz = 0; rm = 0; @@ -47366,12 +144609,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2028097\n"); + $fwrite(fp,"1888663\n"); end - x = 64'h4010000000000001; - y = 64'h3CA0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + x = 64'h51A66E092B01479D; + y = 64'h3FCFFFFFFFFFFFBF; + z = 64'hC35FFFBFFFFFFFBE; + ans = 64'h51866E092B01476F; rn = 1; rz = 0; rm = 0; @@ -47413,12 +144656,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2030111\n"); + $fwrite(fp,"1889277\n"); end - x = 64'h001000001FFFFF80; - y = 64'h3FD0000000000000; - z = 64'h3FCFF8001FFFFFFF; - ans = 64'h3FCFF8001FFFFFFF; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; rn = 1; rz = 0; rm = 0; @@ -47460,623 +144703,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2032125\n"); + $fwrite(fp,"1889891\n"); end - x = 64'hE9017BABC578EAC4; - y = 64'hB87FFFFFFE0001FF; - z = 64'hBFD44A66846F7879; - ans = 64'h61917BABC461311F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2034139\n"); - end - x = 64'h4010000000000001; - y = 64'h3FE0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h4000000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2036153\n"); - end - x = 64'hB80FEFFFFFFFBFFE; - y = 64'h3FF0000000000000; - z = 64'hC7CFFF0000000200; - ans = 64'hC7CFFF0000000200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2038167\n"); - end - x = 64'hC1C1FFFFFFFFFFBF; - y = 64'hC1F20000000007FE; - z = 64'hBEEFDFFFFFFFFFEF; - ans = 64'h43C44000000008B5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2040181\n"); - end - x = 64'h4010000000000001; - y = 64'h4000000000000001; - z = 64'h3FF0000000000001; - ans = 64'h4022000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2042195\n"); - end - x = 64'h43DC00000FFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h403775BC9C46BBBF; - ans = 64'h43FC00000FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2044209\n"); - end - x = 64'h2F82A1B8ACB26B67; - y = 64'h8D400003F7FFFFFE; - z = 64'h3FD1000007FFFFFF; - ans = 64'h3FD1000007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2046223\n"); - end - x = 64'h4010000000000001; - y = 64'h4340000000000000; - z = 64'hC340000000000000; - ans = 64'h4358000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2048237\n"); - end - x = 64'hC6500083FFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - z = 64'h3FDF7FFFFFFFBFFF; - ans = 64'hC9B00083FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2050251\n"); - end - x = 64'h3CE3F7CF953A40DF; - y = 64'h3C3B23C4A3B1C107; - z = 64'h3FD7FFFFFFFFF7FF; - ans = 64'h3FD7FFFFFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2052265\n"); - end - x = 64'h4010000000000001; - y = 64'h7FF0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2054279\n"); - end - x = 64'h2D927E1B4772D416; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hAEC000001FFFFF7F; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2056293\n"); - end - x = 64'h3815633161D11357; - y = 64'h403FFFFF9FFFFFFF; - z = 64'h3FB0000200080000; - ans = 64'h3FB0000200080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2058307\n"); - end - x = 64'h4010000000000001; - y = 64'h8010000000000000; + x = 64'h43EFFFFFFEFFFF7E; + y = 64'hB7FFFFFFFFFFFFF1; z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFC0000001FFF; rn = 1; rz = 0; rm = 0; @@ -48118,12 +144750,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2060321\n"); + $fwrite(fp,"1890505\n"); end - x = 64'hC4DFFFFFFFFFFBFB; - y = 64'h801FFFFFFFFFFFFF; - z = 64'h401023FFFFFFFFFE; - ans = 64'h401023FFFFFFFFFE; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h400FC00000000080; + ans = 64'h400FC00000000080; rn = 1; rz = 0; rm = 0; @@ -48165,12 +144797,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2062335\n"); + $fwrite(fp,"1891119\n"); end - x = 64'h47F422D15FBFC2A7; - y = 64'hC04000001FC00000; - z = 64'h7FDFFEFFFFBFFFFF; - ans = 64'h7FDFFEFFFFBFFFFF; + x = 64'h43D00101FFFFFFFF; + y = 64'hBFEFFFFFFFFEFFFE; + z = 64'h40D2B76E9D285754; + ans = 64'hC3D00101FFFF7FE3; rn = 1; rz = 0; rm = 0; @@ -48212,12 +144844,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2064349\n"); + $fwrite(fp,"1891733\n"); end - x = 64'h4010000000000001; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000005; + x = 64'hBFFFFFFFFFFFEFFD; + y = 64'h3CA0000000000001; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -48259,12 +144891,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2066363\n"); + $fwrite(fp,"1892347\n"); end - x = 64'hBF8FFFFFBFFFFFFB; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'h7FF7FFFFFFFFFFEF; - ans = 64'h7FFFFFFFFFFFFFEF; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC3F0040000010000; + z = 64'hC7F0002010000000; + ans = 64'hC7F0002010000000; rn = 1; rz = 0; rm = 0; @@ -48306,12 +144938,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2068377\n"); + $fwrite(fp,"1892961\n"); end - x = 64'h3FCFFFFFFFFFBFF7; - y = 64'h8000010000020000; - z = 64'hB80000000207FFFF; - ans = 64'hB80000000207FFFF; + x = 64'h9510000000000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hDD7FFFFFFFFFF007; + ans = 64'hDD7FFFFFFFFFF007; rn = 1; rz = 0; rm = 0; @@ -48353,12 +144985,717 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2070391\n"); + $fwrite(fp,"1893575\n"); end - x = 64'h4010000000000001; - y = 64'hBFEFFFFFFFFFFFFE; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h42F00400000001FE; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h43100400000001F5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1894189\n"); + end + x = 64'h403FFFFFFFFFC3FE; + y = 64'hFFF0000000003FF0; + z = 64'hE96D57E9AF40FC9D; + ans = 64'hFFF8000000003FF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1894803\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h3FD0000000000001; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h4013FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1895417\n"); + end + x = 64'hBFC000DFFFFFFFFE; + y = 64'hBFF1FFFFFF800000; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h3FC200FBFF7FF8FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1896031\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3F03FFFBFFFFFFFF; + ans = 64'h40000013FFFBFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1896645\n"); + end + x = 64'h4020000FFFDFFFFE; + y = 64'h7FFFFFFFFBFFFFFC; + z = 64'h002FFEFFDFFFFFFF; + ans = 64'h7FFFFFFFFBFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1897259\n"); + end + x = 64'hBEBEB67F33381F86; + y = 64'h3FE0000000000000; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1897873\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC3D000000003DFFE; + z = 64'hC07FFFFFFFFFBFF7; + ans = 64'hC3F000000003DFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1898487\n"); + end + x = 64'h3FCF000400000000; + y = 64'h3FE0000000000001; + z = 64'hC00E1F43407F411C; + ans = 64'hC00D2743207F411C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1899101\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h4030000007EFFFFF; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h404F80000FDFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1899715\n"); + end + x = 64'h434E104364E5057E; + y = 64'h43D7FEFFFFFFFFFF; + z = 64'h434008000000007F; + ans = 64'h47368B4209909CF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1900329\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h3FF0000000000000; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h4017FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1900943\n"); + end + x = 64'h5DF54479F7781AF7; + y = 64'h4800000101FFFFFF; + z = 64'h0010000000000000; + ans = 64'h6605447B4E6849AC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1901557\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h3FF0000000000001; + z = 64'hC02FFFFFFFFE3FFF; + ans = 64'hC027FFFFFFFE3FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1902171\n"); + end + x = 64'h38065F9B291FB446; + y = 64'hBC900000007FFFFB; + z = 64'h43403FFFFFFFFF7E; + ans = 64'h43403FFFFFFFFF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1902785\n"); + end + x = 64'hC2AB3D1F5ECB8B72; + y = 64'h3FFFFFFFFFFFFFFE; z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFC; + ans = 64'h433FE4C2E0A13475; rn = 1; rz = 0; rm = 0; @@ -48400,12 +145737,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2072405\n"); + $fwrite(fp,"1903399\n"); end - x = 64'h801FC874B609EF56; - y = 64'hBFF0000000000001; - z = 64'h40FD762D718A93A8; - ans = 64'h40FD762D718A93A8; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h1830100100000000; + z = 64'h43F00000001FFEFE; + ans = 64'h43F00000001FFEFE; rn = 1; rz = 0; rm = 0; @@ -48447,12 +145784,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2074419\n"); + $fwrite(fp,"1904013\n"); end - x = 64'h3FAFFFFF00040000; - y = 64'h41C000000000007F; - z = 64'h3FB6225DA8DAFEF7; - ans = 64'h417FFFFF016626D9; + x = 64'hC1E0000000000500; + y = 64'h4000000000000000; + z = 64'hC030FFFFFFFF7FFE; + ans = 64'hC1F0000001100500; rn = 1; rz = 0; rm = 0; @@ -48494,12 +145831,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2076433\n"); + $fwrite(fp,"1904627\n"); end - x = 64'h4010000000000001; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hBFFCEF01E4D5C217; + z = 64'hBFE0000000000000; + ans = 64'hC01EEF01E4D5C215; rn = 1; rz = 0; rm = 0; @@ -48541,12 +145878,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2078447\n"); + $fwrite(fp,"1905241\n"); end - x = 64'h3FDFFF80007FFFFF; - y = 64'hC010000000000001; - z = 64'hC000000003FE0000; - ans = 64'hC00FFFC0043E0000; + x = 64'h400D5F58DE8CF296; + y = 64'hBE0F90E6DD0EA8AE; + z = 64'hC7FFDF0000000000; + ans = 64'hC7FFDF0000000000; rn = 1; rz = 0; rm = 0; @@ -48588,12 +145925,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2080461\n"); + $fwrite(fp,"1905855\n"); end - x = 64'hC7EFF38A13C13651; - y = 64'hC02894BC2E1A6C18; - z = 64'hA220000400000000; - ans = 64'h48288B29D23FF2B2; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h3FF0000000000000; + ans = 64'h4030FFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -48635,12 +145972,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2082475\n"); + $fwrite(fp,"1906469\n"); end - x = 64'h4010000000000001; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC370000000000000; + x = 64'hC33BE1FA91CC8BBC; + y = 64'h3F65E6B30D9F6D97; + z = 64'h0000000000000001; + ans = 64'hC2B31550AC96818D; rn = 1; rz = 0; rm = 0; @@ -48682,12 +146019,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2084489\n"); + $fwrite(fp,"1907083\n"); end - x = 64'h3FB7FFFFBFFFFFFF; - y = 64'hFFE0000000000001; - z = 64'hC04CF36D5B8ACEE5; - ans = 64'hFFA7FFFFC0000000; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h4010000000000000; + z = 64'hBDEF7FEFFFFFFFFF; + ans = 64'h402FFFFFFFFE07FF; rn = 1; rz = 0; rm = 0; @@ -48729,12 +146066,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2086503\n"); + $fwrite(fp,"1907697\n"); end - x = 64'h3FB00000000000FD; - y = 64'h3648D98A332E5571; - z = 64'h35080008E5BACA0B; - ans = 64'h3608D9A233373CB5; + x = 64'h3EB0000000001DFF; + y = 64'hBFC0DE4738EB51D2; + z = 64'h4A0252BE25281E63; + ans = 64'h4A0252BE25281E63; rn = 1; rz = 0; rm = 0; @@ -48776,11 +146113,293 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2088517\n"); + $fwrite(fp,"1908311\n"); end - x = 64'h4010000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; + x = 64'h380FFFFFFFC04000; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1908925\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hBFBFFFFFFDFFFFFC; + z = 64'hC00FBFDFFFFFFFFF; + ans = 64'hC011DFEFFFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1909539\n"); + end + x = 64'h80000002FFFFFFFE; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hC03FFFFFFFFFFF01; + ans = 64'hC03FFFFFFFFFFF01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1910153\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hBCADDF0E689DB01C; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1910767\n"); + end + x = 64'h4000000FFFFFFEFF; + y = 64'hBBD00000000023FF; + z = 64'hBACFFFFFFF1FFFFF; + ans = 64'hBBE00018000022C6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1911381\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h3FE0000000000001; + ans = 64'h436FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1911995\n"); + end + x = 64'h40CF800400000000; + y = 64'h403DD0FF2D97574A; + z = 64'hFFFFFFFFFFFFFFFF; ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -48823,12 +146442,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2090531\n"); + $fwrite(fp,"1912609\n"); end - x = 64'hC3D39F1456976025; - y = 64'h0000000000000000; - z = 64'h7FEFFFFFFF7FFFEF; - ans = 64'h7FEFFFFFFF7FFFEF; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hBFD3FFFFF0000000; + ans = 64'h436FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -48870,12 +146489,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2092545\n"); + $fwrite(fp,"1913223\n"); end - x = 64'h3FC000000000101F; - y = 64'h4D1684A027E5AE5F; - z = 64'h40300000005FFFFE; - ans = 64'h4CE684A027E5C50F; + x = 64'hA93000000FBFFFFE; + y = 64'h383000006FFFFFFF; + z = 64'h3F2FFFEFBFFFFFFE; + ans = 64'h3F2FFFEFBFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -48917,12 +146536,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2094559\n"); + $fwrite(fp,"1913837\n"); end - x = 64'h401FFFFFFFFFFFFF; - y = 64'h0010000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + x = 64'hC340000000000028; + y = 64'h7FE0000000000001; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -48964,12 +146583,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2096573\n"); + $fwrite(fp,"1914451\n"); end - x = 64'h41B5AFA14B1E5380; - y = 64'h3CA0000000000000; - z = 64'h27B003FFEFFFFFFF; - ans = 64'h3E65AFA14B1E5380; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h3FF67E8BCE4F5BD6; + z = 64'h3FDFFFFFFFFFFFEE; + ans = 64'h40187E8BCE4F5BD3; rn = 1; rz = 0; rm = 0; @@ -49011,529 +146630,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2098587\n"); + $fwrite(fp,"1915065\n"); end - x = 64'hBE1FFFF0FFFFFFFF; - y = 64'h3F5FFFFF00000000; - z = 64'h3FCFFFFFFDFBFFFF; - ans = 64'h3FCFFFFFFDFA0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2100601\n"); - end - x = 64'h401FFFFFFFFFFFFF; - y = 64'h3FD0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2102615\n"); - end - x = 64'h07FFFFFE0000003F; - y = 64'h3FE0000000000000; - z = 64'h401D1C3F8CA4CDAC; - ans = 64'h401D1C3F8CA4CDAC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2104629\n"); - end - x = 64'hC7FFFF0200000000; - y = 64'hC7E3DFFFFFFFFFFF; - z = 64'h8021FFFFFFFFFBFF; - ans = 64'h4FF3DF623DFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2106643\n"); - end - x = 64'h401FFFFFFFFFFFFF; - y = 64'h3FF0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h4020000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2108657\n"); - end - x = 64'hC00FFFFFFFF7BFFE; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hBFD47AFA8ED01F9A; - ans = 64'hC020A3D7D47260FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2110671\n"); - end - x = 64'h0A6F3FFFFFFFFFFF; - y = 64'hBD50001003FFFFFE; - z = 64'hB2CEF95F6CEEFEB0; - ans = 64'hB2CEF95F6CEEFEB0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2112685\n"); - end - x = 64'h401FFFFFFFFFFFFF; - y = 64'h4010000000000000; - z = 64'hBFF0000000000001; - ans = 64'h403EFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2114699\n"); - end - x = 64'hB810004000000010; - y = 64'h401FFFFFFFFFFFFE; - z = 64'h403FFF7FFFFFF000; - ans = 64'h403FFF7FFFFFF000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2116713\n"); - end - x = 64'h97F1FFFFFFFFFE00; - y = 64'hC1EEFFFFFFFE0000; - z = 64'h3FF000007FFFFFFC; - ans = 64'h3FF000007FFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2118727\n"); - end - x = 64'h401FFFFFFFFFFFFF; - y = 64'h7FE0000000000000; - z = 64'h4340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2120741\n"); - end - x = 64'hBF90B94940132032; + x = 64'h39DFFFFFFFFFBEFE; y = 64'h7FEFFFFFFFFFFFFF; - z = 64'hFFDFBFFFFFFFDFFF; - ans = 64'hFFE065CA4A008901; + z = 64'hA29FFFFFFEFFF7FF; + ans = 64'h79DFFFFFFFFFBEFD; rn = 1; rz = 0; rm = 0; @@ -49575,200 +146677,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2122755\n"); + $fwrite(fp,"1915679\n"); end - x = 64'h002FFFFFFFF7BFFF; - y = 64'hB12B2946E3E0CC24; - z = 64'h41AAEA0575638D88; - ans = 64'h41AAEA0575638D88; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2124769\n"); - end - x = 64'h401FFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2126783\n"); - end - x = 64'h4100000800020000; - y = 64'h800FFFFFFFFFFFFF; - z = 64'h5C807FFFFFFEFFFF; - ans = 64'h5C807FFFFFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2128797\n"); - end - x = 64'h41C27972E0EE4B70; - y = 64'h41D0001007FFFFFE; - z = 64'h001000000040000F; - ans = 64'h43A27985639DE5CC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2130811\n"); - end - x = 64'h401FFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h3FA00000FFBFFFFF; z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3FC00000FFBFFFF6; rn = 1; rz = 0; rm = 0; @@ -49810,12 +146724,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2132825\n"); + $fwrite(fp,"1916293\n"); end - x = 64'hDE8FE003FFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hC0D20000000007FF; - ans = 64'h5B4FE003FFFFFFFD; + x = 64'hB9AFFFFFFEFFFFFD; + y = 64'hC03FFFFF7FFFFBFF; + z = 64'hC00FFFFFFFFC003E; + ans = 64'hC00FFFFFFFFC003E; rn = 1; rz = 0; rm = 0; @@ -49857,12 +146771,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2134839\n"); + $fwrite(fp,"1916907\n"); end - x = 64'hC3CFFBFBFFFFFFFF; - y = 64'h8000100400000000; - z = 64'h480FFFFFEFEFFFFF; - ans = 64'h480FFFFFEFEFFFFF; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h7FF0000000000001; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; rn = 1; rz = 0; rm = 0; @@ -49904,12 +146818,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2136853\n"); + $fwrite(fp,"1917521\n"); end - x = 64'h401FFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'hC007FFFFFFFFFFFD; + x = 64'h43F6C523A35243F7; + y = 64'hC7FFFDF7FFFFFFFF; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -49951,1280 +146865,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2138867\n"); + $fwrite(fp,"1918135\n"); end - x = 64'hC34FF80000001000; - y = 64'hBFE0000000000001; - z = 64'hC3FF7EFFFFFFFFFE; - ans = 64'hC3FF7D007FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2140881\n"); - end - x = 64'h400FDFFE00000000; - y = 64'h4000BEB28AC6E8DF; - z = 64'hC1DF7FFFF8000000; - ans = 64'hC1DF7FFFF5EA41A6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2142895\n"); - end - x = 64'h401FFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2144909\n"); - end - x = 64'h4020000000003FBE; - y = 64'hC000000000000001; - z = 64'hC1CFEFFFFFFFFF7F; - ans = 64'hC1CFF00007FFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2146923\n"); - end - x = 64'hC01FFFFC00001000; - y = 64'h37E02007FFFFFFFE; - z = 64'hC000000040000200; - ans = 64'hC000000040000200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2148937\n"); - end - x = 64'h401FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2150951\n"); - end - x = 64'h3FCEB158F9D7DFA5; - y = 64'hC340000000000001; - z = 64'hC34C63CAEBFBFE18; - ans = 64'hC3501CFB059B7D06; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2152965\n"); - end - x = 64'hBF70020000000100; - y = 64'hBFB971827803ECEC; - z = 64'h7FF3422AFCE71F00; - ans = 64'h7FFB422AFCE71F00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2154979\n"); - end - x = 64'h401FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2156993\n"); - end - x = 64'h47E00010000FFFFE; - y = 64'hFFF0000000000000; - z = 64'hC3D9B18B35728971; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2159007\n"); - end - x = 64'hB950003FEFFFFFFE; - y = 64'hB7F4003FFFFFFFFE; - z = 64'h3D90000080000400; - ans = 64'h3D90000080000400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2161021\n"); - end - x = 64'h401FFFFFFFFFFFFE; - y = 64'h0000000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2163035\n"); - end - x = 64'h43FE690733095B3F; - y = 64'h0010000000000000; - z = 64'h9C0CF7EB74A0FE9B; - ans = 64'h9C0CF7EB74A0FE9B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2165049\n"); - end - x = 64'h7FD0D3762DCE7F2B; - y = 64'hC01BFE411C7BC401; - z = 64'hAFBB3A77155F16A8; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2167063\n"); - end - x = 64'h401FFFFFFFFFFFFE; - y = 64'h3CA0000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2169077\n"); - end - x = 64'hB7E00001FFFFFF00; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'hB800000001FFFFFF; - ans = 64'hB800000001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2171091\n"); - end - x = 64'hB7FFFE0000000100; - y = 64'h3FBBFFFFFEFFFFFE; - z = 64'h3FB0002000001FFF; - ans = 64'h3FB0002000001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2173105\n"); - end - x = 64'h401FFFFFFFFFFFFE; - y = 64'h3FE0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2175119\n"); - end - x = 64'hC7ED450B577AD8A8; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h41CDEFFFFFFFFFFF; - ans = 64'hC7ED450B577AD8A6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2177133\n"); - end - x = 64'hC3C03FFFFFFFFBFE; - y = 64'h8DEFFFFE07FFFFFF; - z = 64'hBA5FDFFFFF7FFFFF; - ans = 64'hBA5FDFFFFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2179147\n"); - end - x = 64'h401FFFFFFFFFFFFE; - y = 64'h4000000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h402FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2181161\n"); - end - x = 64'h322FFFE004000000; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h400000000400001F; - ans = 64'h400000000400001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2183175\n"); - end - x = 64'h3FE0000FFFFFFFFC; - y = 64'hBCAE000000001FFE; - z = 64'h0010040000000006; - ans = 64'hBC9E001E00001FF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2185189\n"); - end - x = 64'h401FFFFFFFFFFFFE; - y = 64'h4340000000000000; - z = 64'h3FF0000000000001; - ans = 64'h436FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2187203\n"); - end - x = 64'hF02FFFE000000000; - y = 64'h434FFFFFFFFFFFFF; - z = 64'hC1EFBFFFFFFFDFFF; - ans = 64'hF38FFFDFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2189217\n"); - end - x = 64'h40C00007FC000000; - y = 64'hC1CFFFFFF8001FFF; - z = 64'hBF1FFF8000100000; - ans = 64'hC2A00007F8000E01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2191231\n"); - end - x = 64'h401FFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2193245\n"); - end - x = 64'hAEADD75F0AEE4DE6; + x = 64'h400FFFFFFFFFFFFE; y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFE001FFF; + z = 64'h47E0000000007FF7; ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -51267,12 +146912,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2195259\n"); + $fwrite(fp,"1918749\n"); end - x = 64'hC19FDF7FFFFFFFFE; - y = 64'h43DF80003FFFFFFF; - z = 64'hC1C4000000002000; - ans = 64'hC58F60023FBEFFFD; + x = 64'hBCA003FFFFFFFFFA; + y = 64'hC3F000041FFFFFFF; + z = 64'h04EFFFFFFF1FFFFF; + ans = 64'h40A004042107FFF9; rn = 1; rz = 0; rm = 0; @@ -51314,12 +146959,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2197273\n"); + $fwrite(fp,"1919363\n"); end - x = 64'h401FFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + x = 64'hBFD006FFFFFFFFFE; + y = 64'h8000000000000000; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -51361,12 +147006,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2199287\n"); + $fwrite(fp,"1919977\n"); end - x = 64'hC2700000003FF7FF; - y = 64'h801FFFFFFFFFFFFF; - z = 64'hBDFFFFFE7FFFFFFE; - ans = 64'hBDFFFFFE7FFFFFFE; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h381FFFF8FFFFFFFF; + z = 64'hBEFFFFFFF7FFDFFF; + ans = 64'hBEFFFFFFF7FFDFFF; rn = 1; rz = 0; rm = 0; @@ -51408,12 +147053,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2201301\n"); + $fwrite(fp,"1920591\n"); end - x = 64'hC03FFF8200000000; - y = 64'h0A1FFFDFFFFFFFDE; - z = 64'h802CDB4B12FB1438; - ans = 64'h8A6FFF62007DFFDE; + x = 64'hC3DF0BF692B6C42C; + y = 64'h8000000000000001; + z = 64'hC137FFFF7FFFFFFF; + ans = 64'hC137FFFF7FFFFFFF; rn = 1; rz = 0; rm = 0; @@ -51455,12 +147100,529 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2203315\n"); + $fwrite(fp,"1921205\n"); end - x = 64'h401FFFFFFFFFFFFE; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h8028F6B357E9B943; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h804CF6B357E9B941; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1921819\n"); + end + x = 64'h44AFFFFFFFFFC03E; + y = 64'h49FFFFC000000007; + z = 64'hC3FFFF0001FFFFFF; + ans = 64'h4EBFFFBFFFFFC045; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1922433\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h8010000000000000; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1923047\n"); + end + x = 64'hC7AFFFFFFFFFFFFE; + y = 64'h76F6258C5D59960D; + z = 64'hFFE0000000000000; + ans = 64'hFFE00002C4B18BAB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1923661\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h8010000000000001; + z = 64'h5360000005FFFFFF; + ans = 64'h5360000005FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1924275\n"); + end + x = 64'h3FF000000007EFFF; + y = 64'hBFCFFFFFFFFFFDF8; + z = 64'h002BFEFFFFFFFFFE; + ans = 64'hBFD000000007EEFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1924889\n"); + end + x = 64'h3F6CE728121A019E; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1925503\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h4F7000007BFFFFFF; + z = 64'h7FEFFBFFFFFFFFFF; + ans = 64'h7FEFFBFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1926117\n"); + end + x = 64'hBFDEFFFFFFFEFFFF; + y = 64'hBCA0000000000000; + z = 64'hC7E0000001FF0000; + ans = 64'hC7E0000001FF0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1926731\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h422FFFFFFE000FFF; + z = 64'h8010000000000000; + ans = 64'h424FFFFFFE000FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1927345\n"); + end + x = 64'h801004FFFFFFFFFF; + y = 64'hC0109335F5BD73BA; + z = 64'hC01624D57E096811; + ans = 64'hC01624D57E096811; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1927959\n"); + end + x = 64'h400FFFFFFFFFFFFE; y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hBCDBFFFFFFFFFFFC; + z = 64'h3CA0000000000000; + ans = 64'hBCCBFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -51502,12 +147664,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2205329\n"); + $fwrite(fp,"1928573\n"); end - x = 64'hC3CFFFFF000003FF; - y = 64'hBFD0000000000001; - z = 64'h05FEAC5FF2C4D343; - ans = 64'h43AFFFFF00000401; + x = 64'h0000E00000000000; + y = 64'h38020000FFFFFFFF; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; rn = 1; rz = 0; rm = 0; @@ -51549,12 +147711,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2207343\n"); + $fwrite(fp,"1929187\n"); end - x = 64'h3FC013FFFFFFFFFF; - y = 64'h3FC000000FFFFEFE; - z = 64'hBFEDFFFFFFFFDFFF; - ans = 64'hBFED7F5FFF7F4007; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hBFD0000000000000; + z = 64'h41FA150B29B47F8E; + ans = 64'h41FA150B29A47F8E; rn = 1; rz = 0; rm = 0; @@ -51596,12 +147758,294 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2209357\n"); + $fwrite(fp,"1929801\n"); end - x = 64'h401FFFFFFFFFFFFE; + x = 64'h401D1E0FEB280043; + y = 64'h41F00002000003FF; + z = 64'h3CA3E11D80E9DCED; + ans = 64'h421D1E138EEA04EE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1930415\n"); + end + x = 64'hBF2FFFFFFFFFFE7F; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h3FE0000000000001; + ans = 64'h3FE0010000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1931029\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hB81F000040000000; + z = 64'hE5700000200000FF; + ans = 64'hE5700000200000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1931643\n"); + end + x = 64'hC80FF800000001FF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h801FFFFF7DFFFFFE; + ans = 64'h47FFF800000001FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1932257\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC0203DFFFFFFFFFE; + z = 64'h8000000000000001; + ans = 64'hC0403DFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1932871\n"); + end + x = 64'h41EFFFE00001FFFF; + y = 64'h3FFE631C2D8E143B; + z = 64'hD771DCDE9F9BCCFF; + ans = 64'hD771DCDE9F9BCCFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1933485\n"); + end + x = 64'h400FFFFFFFFFFFFE; y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hC021FFFFFFFFFFFF; + z = 64'h0010000000000001; + ans = 64'hC00FFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -51643,12 +148087,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2211371\n"); + $fwrite(fp,"1934099\n"); end - x = 64'h38D407FFFFFFFFFE; + x = 64'hF55000017FFFFFFF; + y = 64'hB34000000000005F; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'h68A000018000005E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1934713\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h47E0000000003DFE; + ans = 64'h47E0000000003DFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1935327\n"); + end + x = 64'hC1FFFFFEFF000000; + y = 64'hBF2FFFE00000001E; + z = 64'h3BC6EBA2A1E6E450; + ans = 64'h413FFFDEFF01011E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1935941\n"); + end + x = 64'h469FFF7FFDFFFFFE; y = 64'hBFF0000000000001; - z = 64'h47EFFFFFFFDFDFFE; - ans = 64'h47EFFFFFFFDFDFFE; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'hC69FFF7FFE000000; rn = 1; rz = 0; rm = 0; @@ -51690,12 +148275,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2213385\n"); + $fwrite(fp,"1936555\n"); end - x = 64'hBD6800000007FFFF; - y = 64'hC3D8A89C08D5D92C; - z = 64'h4000040000000800; - ans = 64'h41527E7586C68D07; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC273FFFFEFFFFFFF; + z = 64'h802000000000003B; + ans = 64'hC293FFFFEFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -51737,12 +148322,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2215399\n"); + $fwrite(fp,"1937169\n"); end - x = 64'h401FFFFFFFFFFFFE; + x = 64'h43F0003FFDFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hC1E0004001FFFFFE; + ans = 64'hC400003FFE04000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1937783\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h3F8F00001FFFFFFF; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1938397\n"); + end + x = 64'h3B90004000007FFF; + y = 64'h3800AF970246D475; + z = 64'h402FFFFFFFFF7FFF; + ans = 64'h402FFFFFFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1939011\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC000000000000001; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hC020000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1939625\n"); + end + x = 64'hC1E007FFFFFFFFFB; + y = 64'hBA8FFFFFFFFFB7FE; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1940239\n"); + end + x = 64'h400FFFFFFFFFFFFE; y = 64'hC00FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFE0; + z = 64'h37F001FFFFFFC000; + ans = 64'hC02FFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -51784,12 +148604,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2217413\n"); + $fwrite(fp,"1940853\n"); end - x = 64'h5A800000001EFFFF; + x = 64'hBF78000000001FFF; + y = 64'hC02FFFFFFF002000; + z = 64'h3DE0003FFFFFFFDF; + ans = 64'h3FB7FFFFFFC039FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1941467\n"); + end + x = 64'hB7FDFFFEFFFFFFFF; y = 64'hC010000000000000; - z = 64'hC02FFFFFE0000010; - ans = 64'hDAA00000001EFFFF; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -51831,12 +148698,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2219427\n"); + $fwrite(fp,"1942081\n"); end - x = 64'hBFF00080003FFFFF; - y = 64'h401FF81000000000; - z = 64'hB27FFFFF001FFFFF; - ans = 64'hC01FF90FC0FFE03E; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hBFD000000007FEFF; + z = 64'hC7F0027FFFFFFFFE; + ans = 64'hC7F0027FFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -51878,10 +148745,151 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2221441\n"); + $fwrite(fp,"1942695\n"); end - x = 64'h401FFFFFFFFFFFFE; - y = 64'hC340000000000001; + x = 64'h3AA04BBDD77BA617; + y = 64'hC010000000000001; + z = 64'hC63FFFC080000000; + ans = 64'hC63FFFC080000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1943309\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hBFDD72EABA1C3A92; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1943923\n"); + end + x = 64'hC1C0000800000000; + y = 64'h394CF5E001AE5770; + z = 64'h3F995E945329308C; + ans = 64'h3F995E945329308C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1944537\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFE; z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; @@ -51925,12 +148933,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2223455\n"); + $fwrite(fp,"1945151\n"); end - x = 64'h3802000080000000; + x = 64'hC80FFFFFFFFF8001; + y = 64'hC08E5FDC6EBD366B; + z = 64'hC000000000000000; + ans = 64'h48AE5FDC6EBCBCED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1945765\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC340000000000001; + z = 64'hC00C0A216E3AA7B1; + ans = 64'hC360000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1946379\n"); + end + x = 64'hBE044E11C9371D80; + y = 64'hFFDFFFDFFFFFEFFE; + z = 64'h3D90080000001FFF; + ans = 64'h7DF44DFD7B254A21; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1946993\n"); + end + x = 64'h3FBF7FFFFFFFEFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3CA0000000000000; + ans = 64'hC31F7FFFFFFFEFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1947607\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'hBFB07DFFFFFFFFFE; + z = 64'h47FFFFFFC000007E; + ans = 64'h47FFFFFFC000007E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1948221\n"); + end + x = 64'hA62FFFFFFFFE7FFF; y = 64'hFFE0000000000000; - z = 64'h70C9B12F3A1F01C1; - ans = 64'hF7F2000080000000; + z = 64'h3AFADEEE30BF7D81; + ans = 64'h661FFFFFFFFE7FFF; rn = 1; rz = 0; rm = 0; @@ -51972,12 +149215,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2225469\n"); + $fwrite(fp,"1948835\n"); end - x = 64'hC010140B934D5FF7; - y = 64'hC03F80000003FFFF; - z = 64'hC00FFFFFFF0FFFFF; - ans = 64'h405EA776CA0BD9F0; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h9550004002000000; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; rn = 1; rz = 0; rm = 0; @@ -52019,12 +149262,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2227483\n"); + $fwrite(fp,"1949449\n"); end - x = 64'h401FFFFFFFFFFFFE; - y = 64'hFFF0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hFFF8000000000001; + x = 64'hFFD0FFF7FFFFFFFF; + y = 64'hC0000F0000000000; + z = 64'hC3D0002000000007; + ans = 64'h7FE10FE7F87FFFFF; rn = 1; rz = 0; rm = 0; @@ -52066,12 +149309,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2229497\n"); + $fwrite(fp,"1950063\n"); end - x = 64'h3CEFFFFFFFEFFBFF; - y = 64'h0000000000000000; - z = 64'hC800010002000000; - ans = 64'hC800010002000000; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -52113,12 +149356,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2231511\n"); + $fwrite(fp,"1950677\n"); end - x = 64'hBEDD24BCCEE2CCD4; - y = 64'h47E00007FFFFFDFF; - z = 64'h3CAFFFFE003FFFFF; - ans = 64'hC6CD24CB6141309F; + x = 64'h37E0040000008000; + y = 64'hBE754C8CB9F3E700; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; rn = 1; rz = 0; rm = 0; @@ -52160,10 +149403,1937 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2233525\n"); + $fwrite(fp,"1951291\n"); end - x = 64'h4340000000000000; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hFFF0000000000000; + z = 64'h47F00000000021FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1951905\n"); + end + x = 64'hBF2CF0D56A2750C2; + y = 64'h40F00FFFF0000000; + z = 64'h002C00000000FFFF; + ans = 64'hC02D0DC622A0A2A9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1952519\n"); + end + x = 64'hBC5FFFFFF8003FFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h0010000000000001; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1953133\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h41E00FFFFFFFFFFE; + z = 64'hB57FFFFE00000007; + ans = 64'h42000FFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1953747\n"); + end + x = 64'h402E953198585D54; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hC34CD17866F2D756; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1954361\n"); + end + x = 64'h4010000000000000; + y = 64'h41F00000FFFFFF00; + z = 64'h4340000000000001; + ans = 64'h4340000200002001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1954975\n"); + end + x = 64'hC010472174A39022; + y = 64'h9B200000001FFF7F; + z = 64'h41F0000080000001; + ans = 64'h41F0000080000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1955589\n"); + end + x = 64'h4010000000000000; + y = 64'h0000000000000001; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1956203\n"); + end + x = 64'hC1FFFFFFFFC0000F; + y = 64'h41E4000000000007; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hC3F3FFFFFFD80010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1956817\n"); + end + x = 64'h4010000000000000; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hC020004000000001; + ans = 64'hC020004000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1957431\n"); + end + x = 64'h7FDFFFEFFFFFBFFF; + y = 64'h37EFFFFF7FFF7FFF; + z = 64'h42F000000200FFFF; + ans = 64'h77DFFFEF7FFF7FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1958045\n"); + end + x = 64'h48008001FFFFFFFF; y = 64'h0010000000000001; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h0820800200000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1958659\n"); + end + x = 64'h4010000000000000; + y = 64'h40468E0D5311E76B; + z = 64'h7FD8AF397CA73FA4; + ans = 64'h7FD8AF397CA73FA4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1959273\n"); + end + x = 64'hC7E3D9A5109F2CE8; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hE52E363441B31C17; + ans = 64'hE52E363441B31C17; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1959887\n"); + end + x = 64'h4010000000000000; + y = 64'h49CF80000000007E; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h49EF80000000007E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1960501\n"); + end + x = 64'h3F807FFFEFFFFFFE; + y = 64'hBFD000077FFFFFFF; + z = 64'hC362000010000000; + ans = 64'hC362000010000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1961115\n"); + end + x = 64'h4010000000000000; + y = 64'h3CA0000000000000; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1961729\n"); + end + x = 64'h3FB003DFFFFFFFFF; + y = 64'h06281763EC9DF0B9; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1962343\n"); + end + x = 64'h4010000000000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h7FF0020000008000; + ans = 64'h7FF8020000008000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1962957\n"); + end + x = 64'hBFDFFC0003FFFFFE; + y = 64'h39704000001FFFFE; + z = 64'hC3CFFFFFFFFFF806; + ans = 64'hC3CFFFFFFFFFF806; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1963571\n"); + end + x = 64'hC03000007C000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1964185\n"); + end + x = 64'h4010000000000000; + y = 64'h3FD000000000020F; + z = 64'hC054CD982D004994; + ans = 64'hC0548D982D00498C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1964799\n"); + end + x = 64'hBD27E1AD5D2B709B; + y = 64'h3FD0000000000001; + z = 64'hC7F0000000002000; + ans = 64'hC7F0000000002000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1965413\n"); + end + x = 64'h4010000000000000; + y = 64'hFFDFE0000FFFFFFF; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1966027\n"); + end + x = 64'h40137F75FC3315AF; + y = 64'hBFD080000001FFFF; + z = 64'hBCAFBFFFFFFFFFFF; + ans = 64'hBFF41B71AC171E4B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1966641\n"); + end + x = 64'h4010000000000000; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC017FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1967255\n"); + end + x = 64'hBFC000000080FFFF; + y = 64'h7FDFFFFF7FFFFEFE; + z = 64'hBFD0000000000000; + ans = 64'hFFAFFFFF8101FEF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1967869\n"); + end + x = 64'h4010000000000000; + y = 64'h3FE0000000000001; + z = 64'hC7E00000407FFFFF; + ans = 64'hC7E00000407FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1968483\n"); + end + x = 64'hBFAC2BA02D28C36A; + y = 64'h800010000000FFFE; + z = 64'h43C0000020004000; + ans = 64'h43C0000020004000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1969097\n"); + end + x = 64'h437A753665F4C413; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1969711\n"); + end + x = 64'h4010000000000000; + y = 64'h7FEFFFF801FFFFFF; + z = 64'h4035D7EF299EB91C; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1970325\n"); + end + x = 64'hC8007FFFFFFFFFF7; + y = 64'h3FF0000000000000; + z = 64'h41E0000200000FFE; + ans = 64'hC8007FFFFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1970939\n"); + end + x = 64'h4010000000000000; + y = 64'h37E00000001FFDFE; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1971553\n"); + end + x = 64'h800BFFFBFFFFFFFF; + y = 64'h452FFBFFDFFFFFFE; + z = 64'h1A5000000001FF80; + ans = 64'h1A5000000001FF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1972167\n"); + end + x = 64'h4010000000000000; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC010000000000000; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1972781\n"); + end + x = 64'hC480000100000001; + y = 64'hC06FFFFFE0100000; + z = 64'hBCA0000000000001; + ans = 64'h45000000F007FF01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1973395\n"); + end + x = 64'h4010000000000000; + y = 64'h4000000000000000; + z = 64'hC01FFFFFFFC007FF; + ans = 64'h3E2FFC0080000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1974009\n"); + end + x = 64'hC16FFFFFDFFFFF7E; + y = 64'h3DB1201419E58E36; + z = 64'h4E1FDFFFFFFFFFFC; + ans = 64'h4E1FDFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1974623\n"); + end + x = 64'hDF50011FFFFFFFFE; + y = 64'h4000000000000001; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1975237\n"); + end + x = 64'h4010000000000000; + y = 64'h47E003FFFFFFFFBF; + z = 64'hC01FFF0000001FFF; + ans = 64'h480003FFFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1975851\n"); + end + x = 64'h402862D346BAA1CA; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h411FFFFFFFFBFEFF; + ans = 64'h412000618B4B1A6A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1976465\n"); + end + x = 64'h4010000000000000; + y = 64'h380FFFFFEFFFF7FE; z = 64'h3FF0000000000001; ans = 64'h3FF0000000000001; rn = 1; @@ -52207,12 +151377,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2235539\n"); + $fwrite(fp,"1977079\n"); end - x = 64'hC1D000000000203F; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h001FFFFFFFFFF7BF; - ans = 64'h81FFFFFFFF80407C; + x = 64'hBEFEEFFFFFFFFFFF; + y = 64'h7FF000003BFFFFFE; + z = 64'h40CF7B1D7B973928; + ans = 64'h7FF800003BFFFFFE; rn = 1; rz = 0; rm = 0; @@ -52254,12 +151424,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2237553\n"); + $fwrite(fp,"1977693\n"); end - x = 64'h7FEFFFC000000800; - y = 64'h001FFFFFFFFFDFBF; - z = 64'h546FFFFF7FFEFFFF; - ans = 64'h546FFFFF7FFEFFFF; + x = 64'h4010000000000000; + y = 64'h4010000000000001; + z = 64'hC000000000000001; + ans = 64'h402C000000000002; rn = 1; rz = 0; rm = 0; @@ -52301,12 +151471,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2239567\n"); + $fwrite(fp,"1978307\n"); end - x = 64'h4340000000000000; - y = 64'h3FD0000000000000; - z = 64'hC340000000000000; - ans = 64'hC338000000000000; + x = 64'h3FB2000000000001; + y = 64'hC035E13C67919490; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'hBFF89D63F483C723; rn = 1; rz = 0; rm = 0; @@ -52348,12 +151518,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2241581\n"); + $fwrite(fp,"1978921\n"); end - x = 64'h3C3FF000FFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h4570100000007FFF; - ans = 64'h4570100000007FFF; + x = 64'h4010000000000000; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h3FE92BD129459E10; + ans = 64'h404064AF44A51677; rn = 1; rz = 0; rm = 0; @@ -52395,12 +151565,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2243595\n"); + $fwrite(fp,"1979535\n"); end - x = 64'hB7EFBFFFFFFFFFFF; - y = 64'hC3E0000003FFFDFF; - z = 64'h400FF7E000000000; - ans = 64'h400FF7E000000000; + x = 64'h3CA1FDFFFFFFFFFF; + y = 64'hB9FC538ED462F3E6; + z = 64'h480FFC000000003E; + ans = 64'h480FFC000000003E; rn = 1; rz = 0; rm = 0; @@ -52442,12 +151612,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2245609\n"); + $fwrite(fp,"1980149\n"); end - x = 64'h4340000000000000; - y = 64'h3FF0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + x = 64'hBFB0E2E2A19DE3CA; + y = 64'h4340000000000000; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC3508717150CEF1E; rn = 1; rz = 0; rm = 0; @@ -52489,12 +151659,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2247623\n"); + $fwrite(fp,"1980763\n"); end - x = 64'h3FF00008007FFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hCC60001FFFFDFFFF; - ans = 64'hCC60001FFFFDFFFF; + x = 64'h4010000000000000; + y = 64'hB80FFFF80000000F; + z = 64'hC1CFFFFFFFFFFE08; + ans = 64'hC1CFFFFFFFFFFE08; rn = 1; rz = 0; rm = 0; @@ -52536,12 +151706,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2249637\n"); + $fwrite(fp,"1981377\n"); end - x = 64'h3FEBFFFFFFDFFFFE; - y = 64'hC3B0080000000FFF; - z = 64'hC3F0000002000002; - ans = 64'hC3F0E07001FF0062; + x = 64'h3FBFFFFFFFFFFFC2; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h462FFFC0007FFFFF; + ans = 64'h462FFFC00080000F; rn = 1; rz = 0; rm = 0; @@ -52583,12 +151753,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2251651\n"); + $fwrite(fp,"1981991\n"); end - x = 64'h4340000000000000; - y = 64'h4010000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h4360000000000000; + x = 64'h4010000000000000; + y = 64'hC80FE0001FFFFFFF; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'hC82FE0001FFFFFFF; rn = 1; rz = 0; rm = 0; @@ -52630,12 +151800,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2253665\n"); + $fwrite(fp,"1982605\n"); end - x = 64'h41F00000FC000000; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h4366FE581A30B534; - ans = 64'h4366FE591A30C4F4; + x = 64'h37F0001FFFFC0000; + y = 64'hC000000800000020; + z = 64'h3FBFFFF800002000; + ans = 64'h3FBFFFF800002000; rn = 1; rz = 0; rm = 0; @@ -52677,12 +151847,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2255679\n"); + $fwrite(fp,"1983219\n"); end - x = 64'h3FDFFFFFFF7FFDFE; - y = 64'h3FC0000009FFFFFE; - z = 64'hA44718752C69A512; - ans = 64'h3FB0000009BFFEFD; + x = 64'h4010000000000000; + y = 64'h7FE0000000000000; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -52724,12 +151894,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2257693\n"); + $fwrite(fp,"1983833\n"); end - x = 64'h4340000000000000; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'h469FFFFFFFFFFFFE; + x = 64'h41E8BF333C53DC11; + y = 64'hBFFFE02000000000; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hC1F8A68CC84AC489; rn = 1; rz = 0; rm = 0; @@ -52771,11 +151941,105 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2259707\n"); + $fwrite(fp,"1984447\n"); end - x = 64'hC149A213672520D5; + x = 64'h4010000000000000; y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h43400000003FF7FF; + z = 64'hC3FFFBFFF8000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1985061\n"); + end + x = 64'h3FC002FFFFFFFFFE; + y = 64'h480FFFFFFFFEFFFE; + z = 64'h884FDFFFFFFFFFFF; + ans = 64'h47E002FFFFFF7FE5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1985675\n"); + end + x = 64'hC150000001FFFFEF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFE; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -52818,12 +152082,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2261721\n"); + $fwrite(fp,"1986289\n"); end - x = 64'h47EFFFFF7FBFFFFF; - y = 64'hC000007FFFFFFFE0; - z = 64'hFFEFFFFFFFFFF7BF; - ans = 64'hFFEFFFFFFFFFF7BF; + x = 64'h4010000000000000; + y = 64'h3FDFE0000000000F; + z = 64'h381000800007FFFF; + ans = 64'h3FFFE0000000000F; rn = 1; rz = 0; rm = 0; @@ -52865,11 +152129,152 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2263735\n"); + $fwrite(fp,"1986903\n"); end - x = 64'h4340000000000000; + x = 64'h61CFFFC000007FFF; + y = 64'h7FF0000000000001; + z = 64'h37EF040000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1987517\n"); + end + x = 64'h4010000000000000; + y = 64'hBFBFFFFFFC00000F; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3E2FFFFF78000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1988131\n"); + end + x = 64'hB815F9F97A094A5C; + y = 64'h43FEFFFFFFF7FFFF; + z = 64'h43CFFFFFFF7FFFFD; + ans = 64'h43CFFFFFFF7FFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1988745\n"); + end + x = 64'h4010000000000000; y = 64'h7FFFFFFFFFFFFFFE; - z = 64'h4340000000000000; + z = 64'hBFEFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -52912,12 +152317,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2265749\n"); + $fwrite(fp,"1989359\n"); end - x = 64'h3FD34FB8606858F1; + x = 64'h800000000003FFFE; + y = 64'h578284B14DFCC6E4; + z = 64'h8000000000000000; + ans = 64'h958284A80BA41FE6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1989973\n"); + end + x = 64'h4010000000000000; y = 64'h8000000000000001; - z = 64'h0010000000F80000; - ans = 64'h0010000000F80000; + z = 64'h3D00001000000020; + ans = 64'h3D00001000000020; rn = 1; rz = 0; rm = 0; @@ -52959,12 +152411,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2267763\n"); + $fwrite(fp,"1990587\n"); end - x = 64'hC33FFFFFFF7FFBFE; - y = 64'h402C8FCD7FBF0B36; - z = 64'h400003FFFFFFF7FE; - ans = 64'hC37C8FCD7F4CC86C; + x = 64'h002FFC0000001FFE; + y = 64'h4820040000000003; + z = 64'h401E4B4C703F7797; + ans = 64'h401E4B4C703F7797; rn = 1; rz = 0; rm = 0; @@ -53006,10 +152458,6214 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2269777\n"); + $fwrite(fp,"1991201\n"); end - x = 64'h4340000000000000; + x = 64'hFFF090069ECD0983; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC010000000000000; + ans = 64'hFFF890069ECD0983; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1991815\n"); + end + x = 64'h4010000000000000; + y = 64'h802FFE0100000000; + z = 64'h266FFFFFFBC00000; + ans = 64'h266FFFFFFBC00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1992429\n"); + end + x = 64'h2F9A42B08462C128; + y = 64'h8010000000000000; + z = 64'hC800004001FFFFFF; + ans = 64'hC800004001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1993043\n"); + end + x = 64'h4010000000000000; + y = 64'h7FDFFFFBFEFFFFFF; + z = 64'h3FD0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1993657\n"); + end + x = 64'hC27BDFFFFFFFFFFF; + y = 64'hBFD415B58CED442A; + z = 64'hC3F657E5A2C1DB31; + ans = 64'hC3F657E59A02669E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1994271\n"); + end + x = 64'h4010000000000000; y = 64'h801FFFFFFFFFFFFF; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1994885\n"); + end + x = 64'h801000000000005F; + y = 64'h3FEE0000000000FF; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1995499\n"); + end + x = 64'h4010000000000000; + y = 64'hBCA0000000000000; + z = 64'h40D0001010000000; + ans = 64'h40D0001010000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1996113\n"); + end + x = 64'hC7A95C960A5C58BF; + y = 64'h404000FFFFFDFFFF; + z = 64'hC7F58C9EBE2500D7; + ans = 64'hC807756548EF69E4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1996727\n"); + end + x = 64'h403FFFC003FFFFFE; + y = 64'hBCA0000000000001; + z = 64'hC000000000000001; + ans = 64'hC000000000000009; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1997341\n"); + end + x = 64'h4010000000000000; + y = 64'h801020000FFFFFFF; + z = 64'hBFE00000081FFFFF; + ans = 64'hBFE00000081FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1997955\n"); + end + x = 64'h8010000017FFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h37EEFFFFFFFFFFFA; + ans = 64'h37EEFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1998569\n"); + end + x = 64'h4010000000000000; + y = 64'hC3F8AC97F983EA17; + z = 64'h3CA0000000000001; + ans = 64'hC418AC97F983EA17; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1999183\n"); + end + x = 64'h3F6FFDFFFFFFFF7F; + y = 64'hC03A51B5C97AF6EB; + z = 64'hC000000010000FFF; + ans = 64'hC000D280957102F6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1999797\n"); + end + x = 64'h4010000000000000; + y = 64'hBFD0000000000001; + z = 64'hBFD0000000000001; + ans = 64'hBFF4000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2000411\n"); + end + x = 64'h3F4FFFBFFFFFFFFF; + y = 64'hBFC00001FFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2001025\n"); + end + x = 64'h4010000000000000; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h3FB0003FFFFFFFDF; + ans = 64'hBFFEFFFC00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2001639\n"); + end + x = 64'h67CC0B0B8FFD1579; + y = 64'hC1F9F508DABEAAB9; + z = 64'h37FFFFFFFFFFE00F; + ans = 64'hE9D6BF5D5B795C69; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2002253\n"); + end + x = 64'hC3E40000001FFFFE; + y = 64'hBFE0000000000000; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h43D40000001FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2002867\n"); + end + x = 64'h4010000000000000; + y = 64'hC91FFFFFFFFFC001; + z = 64'hBF8FE00040000000; + ans = 64'hC93FFFFFFFFFC001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2003481\n"); + end + x = 64'h338FFFFDFFDFFFFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h43E0200800000000; + ans = 64'h43E0200800000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2004095\n"); + end + x = 64'h4010000000000000; + y = 64'h3F5FFFFFFFD80000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h3F7FFFFFFFD80000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2004709\n"); + end + x = 64'hE96FFFFEFF7FFFFF; + y = 64'h3FF1FFFFBFFFFFFE; + z = 64'hBFCFFFF800000040; + ans = 64'hE971FFFF2FB801FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2005323\n"); + end + x = 64'h4010000000000000; + y = 64'hBFF0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2005937\n"); + end + x = 64'h3D200007FFFFFFEF; + y = 64'hC00876C4B616918C; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2006551\n"); + end + x = 64'h4010000000000000; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hCFA4200000000000; + ans = 64'hCFA4200000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2007165\n"); + end + x = 64'hA60FC80000000000; + y = 64'hFFE107FFFFFFFFFF; + z = 64'hFFDFFFC800000000; + ans = 64'hFFDFFFC800000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2007779\n"); + end + x = 64'hC180001FFFFFE000; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h4190001FFBFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2008393\n"); + end + x = 64'h4010000000000000; + y = 64'h401389E4A0774013; + z = 64'h47F00003FFFDFFFF; + ans = 64'h47F00003FFFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2009007\n"); + end + x = 64'hB7E4A4C01BE0366D; + y = 64'hC000000000000001; + z = 64'h4030040000000000; + ans = 64'h4030040000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2009621\n"); + end + x = 64'h4010000000000000; + y = 64'h3DD822906B7C1856; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h3DF822906B7C1856; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2010235\n"); + end + x = 64'hBF300003FFFFFFFA; + y = 64'h4663B7CF95147D4D; + z = 64'hC020000FFFFFDFFF; + ans = 64'hC5A3B7D48308628B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2010849\n"); + end + x = 64'h4010000000000000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hC02FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2011463\n"); + end + x = 64'h480F803FFFFFFFFF; + y = 64'hFFD01FFFFFFFFFC0; + z = 64'h4340000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2012077\n"); + end + x = 64'h4010000000000000; + y = 64'hC010000000000001; + z = 64'hBFAA9630F7FA91E2; + ans = 64'hC0300D4B187BFD4A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2012691\n"); + end + x = 64'h46BFFFFFFFFBE000; + y = 64'hFFDFFFFFFFE00020; + z = 64'h001D7B4EBB1E2287; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2013305\n"); + end + x = 64'hBFDFFFFFFC000400; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hBFE0000000000000; + ans = 64'h400BFFFFFC0003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2013919\n"); + end + x = 64'h4010000000000000; + y = 64'h65E6E9986A054481; + z = 64'h3FC0017FFFFFFFFE; + ans = 64'h6606E9986A054481; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2014533\n"); + end + x = 64'h400FFFFFFF7BFFFE; + y = 64'hC340000000000000; + z = 64'hBFF0800000000010; + ans = 64'hC35FFFFFFF7BFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2015147\n"); + end + x = 64'h4010000000000000; + y = 64'hBFDFFFFFFFF02000; + z = 64'h0000000000000000; + ans = 64'hBFFFFFFFFFF02000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2015761\n"); + end + x = 64'hB8E0004080000000; + y = 64'hC1E007FFFFFFEFFF; + z = 64'hC1F04C3464638FD0; + ans = 64'hC1F04C3464638FD0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2016375\n"); + end + x = 64'h4010000000000000; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h8010000000000000; + ans = 64'hC36FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2016989\n"); + end + x = 64'h2F1F7FF800000000; + y = 64'h3FA5BD663D679381; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2017603\n"); + end + x = 64'h4010000000000000; + y = 64'hFFE0000000000000; + z = 64'hC95FFFEFFFFDFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2018217\n"); + end + x = 64'hBFDEFFFFFF000000; + y = 64'h002FFFFFFFFC3FFE; + z = 64'h0000002003FFFFFE; + ans = 64'h801EFFDFFAFC5E00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2018831\n"); + end + x = 64'h3FC0000000000021; + y = 64'hFFE0000000000001; + z = 64'hBFD0000000000001; + ans = 64'hFFB0000000000022; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2019445\n"); + end + x = 64'h4010000000000000; + y = 64'h7FD000011FFFFFFE; + z = 64'h480A9FA0EAF588F8; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2020059\n"); + end + x = 64'h7FFFE00000100000; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hC05FFFFFFFFFFF0F; + ans = 64'h7FFFE00000100000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2020673\n"); + end + x = 64'h4010000000000000; + y = 64'hBFB4E50445E15FFE; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2021287\n"); + end + x = 64'hC34FFFFFF80007FE; + y = 64'h43D0047FFFFFFFFF; + z = 64'h41C87C353CDA6D3F; + ans = 64'hC730047FFBFEE3FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2021901\n"); + end + x = 64'h4010000000000000; + y = 64'hFFF0000000000001; + z = 64'h8000000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2022515\n"); + end + x = 64'h578E007FFFFFFFFF; + y = 64'hC3CFFE7FFFFFFFFE; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'hDB6DFF17F9FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2023129\n"); + end + x = 64'h4010000000000000; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h7FEFFFFFBFFFFFDE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2023743\n"); + end + x = 64'hC34FFF5FFFFFFFFE; + y = 64'hA21403EE84EDAC39; + z = 64'hC1EFFFFFEFFFFFFF; + ans = 64'hC1EFFFFFEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2024357\n"); + end + x = 64'hBFDDFFFFFFFFFFF6; + y = 64'h0000000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2024971\n"); + end + x = 64'h4010000000000001; + y = 64'h390400000000FFFE; + z = 64'h41CB3043321369C3; + ans = 64'h41CB3043321369C3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2025585\n"); + end + x = 64'h37FFFFFFFFFFFFEE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hBC600010001FFFFF; + ans = 64'hBC600010001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2026199\n"); + end + x = 64'h4010000000000001; + y = 64'hB7F1000000000002; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2026813\n"); + end + x = 64'hFFD3F02B09C09A41; + y = 64'hC031200000000000; + z = 64'hC34BB5F53BEB70B5; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2027427\n"); + end + x = 64'h4010000000000001; + y = 64'h0010000000000000; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2028041\n"); + end + x = 64'h381FFF801FFFFFFF; + y = 64'h43EFFE0007FFFFFE; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2028655\n"); + end + x = 64'h4010000000000001; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hBFDFFF0007FFFFFF; + ans = 64'hBFDFFF0007FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2029269\n"); + end + x = 64'h40022DF889E0460E; + y = 64'h480083FFFFFFFFFF; + z = 64'hBFE003FFDFFFFFFF; + ans = 64'h4812C3F3CC51C04F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2029883\n"); + end + x = 64'h404FFFFFFF00003E; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h007F7FFFFF00003C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2030497\n"); + end + x = 64'h4010000000000001; + y = 64'h43D000001EFFFFFF; + z = 64'hBA736F94D9A1D3B3; + ans = 64'h43F000001F000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2031111\n"); + end + x = 64'h3FD00003FFFFFFEF; + y = 64'h3CA0000000000001; + z = 64'h15407FFFFFFFFF80; + ans = 64'h3C800003FFFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2031725\n"); + end + x = 64'h4010000000000001; + y = 64'h7FEFFFFF7FFFFEFF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2032339\n"); + end + x = 64'hC78FFFFFFFF7FEFE; + y = 64'hC6C5A9C8AB5EEB18; + z = 64'h3F7007FFFFEFFFFF; + ans = 64'h4E65A9C8AB597FF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2032953\n"); + end + x = 64'h4010000000000001; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2033567\n"); + end + x = 64'h42A000000FFFFF00; + y = 64'hBFD3000000000000; + z = 64'h3FF0000000000000; + ans = 64'hC283000012FFF6D0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2034181\n"); + end + x = 64'h4010000000000001; + y = 64'h3FD0000000000001; + z = 64'hBCAFFFFFDFFFEFFE; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2034795\n"); + end + x = 64'h400101E2034348A8; + y = 64'h3800000FFFFFC000; + z = 64'h801000000000FFFD; + ans = 64'h381101F3052507E4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2035409\n"); + end + x = 64'hC3D73FF233226D60; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h8010000000000000; + ans = 64'hC3C73FF233226D5F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2036023\n"); + end + x = 64'h4010000000000001; + y = 64'h4331EBC8B95B9247; + z = 64'h001F7FFEFFFFFFFF; + ans = 64'h4351EBC8B95B9248; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2036637\n"); + end + x = 64'hBDE82DB0311C0CE4; + y = 64'h3FE0000000000000; + z = 64'hB7F0000003FFFFFB; + ans = 64'hBDD82DB0311C0CE4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2037251\n"); + end + x = 64'h4010000000000001; + y = 64'h417FE00000002000; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFF8080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2037865\n"); + end + x = 64'h4691FFFBFFFFFFFF; + y = 64'h0D0FFFF020000000; + z = 64'hC27ABBD29987D6DC; + ans = 64'hC27ABBD29987D6DC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2038479\n"); + end + x = 64'h4010000000000001; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2039093\n"); + end + x = 64'h43F003FBFFFFFFFE; + y = 64'hBFEFF00000007FFF; + z = 64'h3FE0000000000001; + ans = 64'hC3EFF7F40400801B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2039707\n"); + end + x = 64'h4010000000000001; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h407FFFE000FFFFFE; + ans = 64'h40801FF0007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2040321\n"); + end + x = 64'h40CCF306BA45AE38; + y = 64'hA6A00000000207FF; + z = 64'h7FD1002000000000; + ans = 64'h7FD1002000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2040935\n"); + end + x = 64'hBF7FBFFFFFBFFFFE; + y = 64'h3FF0000000000001; + z = 64'h8000000000000001; + ans = 64'hBF7FBFFFFFC00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2041549\n"); + end + x = 64'h4010000000000001; + y = 64'h402828229504FC88; + z = 64'hFFD5A537DFEEA9A8; + ans = 64'hFFD5A537DFEEA9A8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2042163\n"); + end + x = 64'h3C1000000000037F; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h2516ADF118D6B0B6; + ans = 64'h3C2000000000037E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2042777\n"); + end + x = 64'h4010000000000001; + y = 64'hBF1FBFFFFFFF7FFF; + z = 64'hC010000000000001; + ans = 64'hC010007EFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2043391\n"); + end + x = 64'hCC50000000000FBF; + y = 64'h3FFFFBFFFEFFFFFE; + z = 64'hB7E0008000000006; + ans = 64'hCC5FFBFFFF001F78; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2044005\n"); + end + x = 64'h4010000000000001; + y = 64'h4000000000000001; + z = 64'h4340000000000001; + ans = 64'h4340000000000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2044619\n"); + end + x = 64'h5EB0734C2E41E43E; + y = 64'hC1F0000000200040; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'hE0B0734C2E62CB18; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2045233\n"); + end + x = 64'h4010000000000001; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hCE1000000027FFFF; + ans = 64'hCE1000000027FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2045847\n"); + end + x = 64'h802EFFFFFFFFFE00; + y = 64'h41EFF0000000001F; + z = 64'hBCEFFC0001FFFFFF; + ans = 64'hBCEFFC0001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2046461\n"); + end + x = 64'h98700000000001BF; + y = 64'h4010000000000000; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2047075\n"); + end + x = 64'h4010000000000001; + y = 64'hD3100000FF000000; + z = 64'hBF40000000101FFF; + ans = 64'hD3300000FF000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2047689\n"); + end + x = 64'h437F000000002000; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h570FFDFFFFFFFBFE; + ans = 64'h570FFDFFFFFFFBFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2048303\n"); + end + x = 64'h4010000000000001; + y = 64'hBC6FFFFF80004000; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2048917\n"); + end + x = 64'hB81E07FFFFFFFFFF; + y = 64'h3FEC000007FFFFFE; + z = 64'h3C6040000000003E; + ans = 64'h3C6040000000003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2049531\n"); + end + x = 64'h4010000000000001; + y = 64'h4340000000000000; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h4360000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2050145\n"); + end + x = 64'hC0CEF80000000000; + y = 64'h4010000401000000; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'hC0EEF807BFEF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2050759\n"); + end + x = 64'h4010000000000001; + y = 64'h4340000000000001; + z = 64'h3810000000040001; + ans = 64'h4360000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2051373\n"); + end + x = 64'h402FFFFFFFF80020; + y = 64'hDC5000FFFFFFFFE0; + z = 64'hB428005DA0DF19DC; + ans = 64'hDC9000FFFFFBFFB0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2051987\n"); + end + x = 64'hBF809DB40C6850A4; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2052601\n"); + end + x = 64'h4010000000000001; + y = 64'h381FFFFFF0080000; + z = 64'h7FF7FBFFFFFFFFFF; + ans = 64'h7FFFFBFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2053215\n"); + end + x = 64'hBCA01FFFFFFFBFFF; + y = 64'h7FE0000000000000; + z = 64'h47EE010000000000; + ans = 64'hFC901FFFFFFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2053829\n"); + end + x = 64'h4010000000000001; + y = 64'h43F10FFFFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'h44110FFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2054443\n"); + end + x = 64'hC3ACF9C2E5A7EDD3; + y = 64'hBCA0000000000000; + z = 64'h3F2000000001FFDE; + ans = 64'h405CF9C4E5A7EDD3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2055057\n"); + end + x = 64'h4010000000000001; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2055671\n"); + end + x = 64'hFFF0000004003FFE; + y = 64'h6A9FFBFFFFDFFFFF; + z = 64'h3CA0000000000000; + ans = 64'hFFF8000004003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2056285\n"); + end + x = 64'h4010000000000001; + y = 64'h7FF0000000000000; + z = 64'hC061FFFFFFFFFFFA; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2056899\n"); + end + x = 64'h3FD351BAD190EE0E; + y = 64'hFB20103FFFFFFFFF; + z = 64'h44FA1AFBC4ECDEF6; + ans = 64'hFB036559D34DC53F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2057513\n"); + end + x = 64'h41E000FFFFFFFFF7; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h7FE0000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2058127\n"); + end + x = 64'h4010000000000001; + y = 64'h3FF38C1608094E37; + z = 64'hB90DFCA930882C14; + ans = 64'h40138C1608094E38; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2058741\n"); + end + x = 64'h802FBFF000000000; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h402FFFFFFDFFFF7F; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2059355\n"); + end + x = 64'h4010000000000001; + y = 64'h4036F22DF5763FE7; + z = 64'hBFF0000000000000; + ans = 64'h4056B22DF5763FE8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2059969\n"); + end + x = 64'h3FF6FE2E918FDD2B; + y = 64'hB7E0E00000000000; + z = 64'hC02418F02A11FD65; + ans = 64'hC02418F02A11FD65; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2060583\n"); + end + x = 64'h4010000000000001; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2061197\n"); + end + x = 64'h37EE8DC9DCAE85C1; + y = 64'h002001FFFFFFFFFC; + z = 64'h0010000000000001; + ans = 64'h0010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2061811\n"); + end + x = 64'h4010000000000001; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h356FFFFFF8800000; + ans = 64'h356FFFFFF8800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2062425\n"); + end + x = 64'h37F0000000005FFE; + y = 64'hB8000005FFFFFFFF; + z = 64'h3CE0002004000000; + ans = 64'h3CE0002004000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2063039\n"); + end + x = 64'hFFD0000000000000; + y = 64'h8010000000000001; + z = 64'h4340000000000001; + ans = 64'h4340000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2063653\n"); + end + x = 64'h4010000000000001; + y = 64'hB8100800000003FF; + z = 64'hC3E0000004040000; + ans = 64'hC3E0000004040000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2064267\n"); + end + x = 64'h43C7FFFBFFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h401DFFFFFFFFFFEF; + ans = 64'h401DFFFFFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2064881\n"); + end + x = 64'h4010000000000001; + y = 64'hB8C0003FFFFFFFFE; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2065495\n"); + end + x = 64'hB80000FFFFFFFFF0; + y = 64'h7FF0000800000003; + z = 64'h99D7403FC620853D; + ans = 64'h7FF8000800000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2066109\n"); + end + x = 64'h4010000000000001; + y = 64'hBCA0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2066723\n"); + end + x = 64'hCD872EAD1D5E17B0; + y = 64'hC800001FFFFFDFFF; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h55972EDB7AB8240D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2067337\n"); + end + x = 64'h4010000000000001; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3EA0000002000080; + ans = 64'h3EA0000001800080; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2067951\n"); + end + x = 64'h4F300013FFFFFFFF; + y = 64'hC0BFE34666739635; + z = 64'h40372CC2C5156BE3; + ans = 64'hCFFFE36E428B9643; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2068565\n"); + end + x = 64'hC5DFFFFFFFFBF800; + y = 64'hBFD0000000000000; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h45BFFFFFFFFBF800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2069179\n"); + end + x = 64'h4010000000000001; + y = 64'h703FFFFFFFFC0008; + z = 64'hBFF0000007FFFFFF; + ans = 64'h705FFFFFFFFC000A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2069793\n"); + end + x = 64'h0020010000000003; + y = 64'hBFD0000000000001; + z = 64'h41DAD18B4B15E433; + ans = 64'h41DAD18B4B15E433; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2070407\n"); + end + x = 64'h4010000000000001; + y = 64'h3FDFFFFBFF000000; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h3FF7FFFBFF000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2071021\n"); + end + x = 64'hB7FFFFAFFFFFFFFF; + y = 64'hBFA0000007FFFBFF; + z = 64'hC02FFFFFF8000020; + ans = 64'hC02FFFFFF8000020; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2071635\n"); + end + x = 64'h4010000000000001; + y = 64'hBFE0000000000000; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'hBFF0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2072249\n"); + end + x = 64'h4050000FFFFF8000; + y = 64'h3FEFFFFFFFFFFFB7; z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; @@ -53053,153 +158709,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2271791\n"); + $fwrite(fp,"2072863\n"); end - x = 64'hC7F49BB4F2B51C99; - y = 64'hBCA0000000000001; - z = 64'h3F9337227034EFC6; - ans = 64'h44A49BB4F2B51C9A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2273805\n"); - end - x = 64'hC7F000001FFFBFFE; - y = 64'h406E708B91074D66; - z = 64'hE5015B4D0390A03B; - ans = 64'hE5015B4D0390A03B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2275819\n"); - end - x = 64'h4340000000000000; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC32FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2277833\n"); - end - x = 64'h4D07FFFFFFFFFF7F; + x = 64'h4010000000000001; y = 64'hBFE0000000000001; - z = 64'hBFF2B6D73D069A54; - ans = 64'hCCF7FFFFFFFFFF80; + z = 64'h58B0023FFFFFFFFF; + ans = 64'h58B0023FFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -53241,12 +158756,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2279847\n"); + $fwrite(fp,"2073477\n"); end - x = 64'h9F4EE4BEA2031544; - y = 64'hD8E0000200FFFFFE; - z = 64'hBFEFFFF00FFFFFFF; - ans = 64'hBFEFFFF00FFFFFFF; + x = 64'hC0D00407FFFFFFFF; + y = 64'h44560B21BC8DFFBC; + z = 64'h45D000007FFFC000; + ans = 64'h45CFF4F8A83A38FF; rn = 1; rz = 0; rm = 0; @@ -53288,12 +158803,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2281861\n"); + $fwrite(fp,"2074091\n"); end - x = 64'h4340000000000000; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'hC34FFFFFFFFFFFFE; + x = 64'h43CC0000001FFFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'hC3CC0000001FFFFD; rn = 1; rz = 0; rm = 0; @@ -53335,12 +158850,294 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2283875\n"); + $fwrite(fp,"2074705\n"); end - x = 64'h801000FFDFFFFFFF; + x = 64'h4010000000000001; + y = 64'h001FFFFFEFFFFFF7; + z = 64'hE5FFFFFFFFFFFFFE; + ans = 64'hE5FFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2075319\n"); + end + x = 64'h3FAFFFDFF7FFFFFE; + y = 64'hBFF0000000000000; + z = 64'hC1EFFF7FFFDFFFFF; + ans = 64'hC1EFFF7FFFE1FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2075933\n"); + end + x = 64'h4010000000000001; + y = 64'h7FEFDFFFFFF80000; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2076547\n"); + end + x = 64'h3FCF0000000FFFFF; + y = 64'hC54BFFFFFFF7FFFE; + z = 64'h380FFFFFFFFFFC10; + ans = 64'hC52B200000063FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2077161\n"); + end + x = 64'h4010000000000001; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'hC01E000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2077775\n"); + end + x = 64'hC34000000FFEFFFE; + y = 64'hC000000000000009; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2078389\n"); + end + x = 64'h4010000000000001; y = 64'hC000000000000000; - z = 64'h41BFFFFFE0004000; - ans = 64'h41BFFFFFE0004000; + z = 64'hB810000000040400; + ans = 64'hC020000000000001; rn = 1; rz = 0; rm = 0; @@ -53382,12 +159179,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2285889\n"); + $fwrite(fp,"2079003\n"); end - x = 64'h000FF90000000000; - y = 64'h80206152B561929D; - z = 64'hB6FFFFFFFFFBFFFD; - ans = 64'hB6FFFFFFFFFBFFFD; + x = 64'hCCFFFFC0000FFFFE; + y = 64'hC3F11E81095D5E21; + z = 64'hBE2FF8000007FFFF; + ans = 64'h51011E5ECC63DAA6; rn = 1; rz = 0; rm = 0; @@ -53429,12 +159226,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2287903\n"); + $fwrite(fp,"2079617\n"); end - x = 64'h4340000000000000; - y = 64'hC010000000000001; - z = 64'hC340000000000000; - ans = 64'hC364000000000001; + x = 64'hBD4FFFDFDFFFFFFE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h4000000000000000; + ans = 64'h4000000000000800; rn = 1; rz = 0; rm = 0; @@ -53476,12 +159273,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2289917\n"); + $fwrite(fp,"2080231\n"); end - x = 64'h80200004000003FE; - y = 64'hC340000000000000; - z = 64'h5B11C4D28BC5C118; - ans = 64'h5B11C4D28BC5C118; + x = 64'h4010000000000001; + y = 64'h3FB639FC3EC1E7C8; + z = 64'h47F1FFFFFFFFF7FF; + ans = 64'h47F1FFFFFFFFF7FF; rn = 1; rz = 0; rm = 0; @@ -53523,12 +159320,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2291931\n"); + $fwrite(fp,"2080845\n"); end - x = 64'h644FFFFFEFFFFF7E; - y = 64'hC02FEFFFFFFFEFFE; - z = 64'h3CA0000000FF7FFF; - ans = 64'hE48FEFFFF007EF7C; + x = 64'h37E0000002001FFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h41F00007FFFFFFEF; + ans = 64'h41F00007FFFFFFEF; rn = 1; rz = 0; rm = 0; @@ -53570,10 +159367,1279 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2293945\n"); + $fwrite(fp,"2081459\n"); end - x = 64'h4340000000000000; + x = 64'h4010000000000001; + y = 64'hBFD0000FBFFFFFFF; + z = 64'hBCA0000000000000; + ans = 64'hBFF0000FC0000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2082073\n"); + end + x = 64'h3CA0000FFFFFFFEE; + y = 64'h0A0FFE0080000000; + z = 64'h3FA00000000FFEFF; + ans = 64'h3FA00000000FFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2082687\n"); + end + x = 64'h4010000000000001; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h3FD0000000000000; + ans = 64'hC03FC00000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2083301\n"); + end + x = 64'hC01EDEE0EE02DDAB; + y = 64'hC02EAF41CE1BC0BD; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2083915\n"); + end + x = 64'h4010000000000001; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hC0EFF6FFFFFFFFFF; + ans = 64'hC0EFFAFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2084529\n"); + end + x = 64'h406E5774F05A50D8; + y = 64'h002F808000000000; + z = 64'h7FF000000200007F; + ans = 64'h7FF800000200007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2085143\n"); + end + x = 64'hC02FFE0000008000; + y = 64'hC340000000000001; + z = 64'h3FF0000000000001; + ans = 64'h437FFE0000008002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2085757\n"); + end + x = 64'h4010000000000001; + y = 64'h401FFE0001FFFFFF; + z = 64'h747A807778879FF0; + ans = 64'h747A807778879FF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2086371\n"); + end + x = 64'h800000101FFFFFFE; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC3E29498223D1003; + ans = 64'hC3E29498223D1003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2086985\n"); + end + x = 64'h4010000000000001; + y = 64'h4010000000000407; + z = 64'h8010000000000001; + ans = 64'h4030000000000408; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2087599\n"); + end + x = 64'hC3D10560432CD7FD; + y = 64'h40700000000007FC; + z = 64'hBD23FFFBFFFFFFFE; + ans = 64'hC4510560432CE07B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2088213\n"); + end + x = 64'h4010000000000001; y = 64'hFFE0000000000001; + z = 64'h3CA0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2088827\n"); + end + x = 64'hBF4003FFFFDFFFFF; + y = 64'h415000003FFFF7FF; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC350000000000200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2089441\n"); + end + x = 64'h4010000000000001; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hB7FFFE00000003FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2090055\n"); + end + x = 64'h43D00000002FFFFF; + y = 64'hBFDFFF000000FFFF; + z = 64'hC34FFFFFBFE00000; + ans = 64'hC3C01F7FFFF05E7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2090669\n"); + end + x = 64'hC7E0000007FFFFF6; + y = 64'hFFF0000000000000; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2091283\n"); + end + x = 64'h4010000000000001; + y = 64'hCD22000000200000; + z = 64'hC3DFFFFFFFF7FFFE; + ans = 64'hCD42000000200001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2091897\n"); + end + x = 64'hC1C0800003FFFFFF; + y = 64'hFFF0000000000001; + z = 64'hC1DFFFFFCFFFFFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2092511\n"); + end + x = 64'h4010000000000001; + y = 64'hC3A00001FEFFFFFE; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'hC3C00001FEFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2093125\n"); + end + x = 64'h321FFFFFDC000000; + y = 64'hC3400000001FEFFF; + z = 64'h43EFFFFFDFFEFFFF; + ans = 64'h43EFFFFFDFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2093739\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h0000000000000000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h001FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2094353\n"); + end + x = 64'hC7E7BF896056C7B0; + y = 64'hC1FFFFFFFEFBFFFE; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'h49F7BF895F95D372; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2094967\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h0000000000000001; + z = 64'h462FFFFFFFFFFFFF; + ans = 64'h462FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2095581\n"); + end + x = 64'h802000000007FF7F; + y = 64'h7FE0000001FFBFFE; + z = 64'h43F1FFFBFFFFFFFE; + ans = 64'h43F1FFFBFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2096195\n"); + end + x = 64'h427F5A5B8669FAAB; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2096809\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC3FFFBFFFFFFFFEF; + z = 64'hC1D000000000FF7E; + ans = 64'hC42FFC0000007FEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2097423\n"); + end + x = 64'h49500000003FFF7E; + y = 64'h0010000000000000; + z = 64'hC261FFFF7FFFFFFE; + ans = 64'hC261FFFF7FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2098037\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC3EA56D05D78BE9F; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -53617,11 +160683,2079 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2295959\n"); + $fwrite(fp,"2098651\n"); end - x = 64'h47F15827436BE817; - y = 64'hFFF0000000000000; - z = 64'hBFB64253798AD5C5; + x = 64'hC341FFFFBFFFFFFF; + y = 64'h41FC0000007FFFFE; + z = 64'hC3F0003FDFFFFFFF; + ans = 64'hC54F80001091FEFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2099265\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h0050FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2099879\n"); + end + x = 64'hBD0000000077FFFF; + y = 64'hC110000010000080; + z = 64'hC010000000000000; + ans = 64'hC00FFFFFFFC00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2100493\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h3CA0000000000000; + z = 64'h988F384F6949CF89; + ans = 64'h3CCFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2101107\n"); + end + x = 64'h480B5B7C936D05AE; + y = 64'h41C0000000400FFE; + z = 64'hBDA0000008200000; + ans = 64'h49DB5B7C93DA8EF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2101721\n"); + end + x = 64'h0BA24ED74A49604E; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2102335\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hBFD001000000001E; + z = 64'h381F019FB1D0E921; + ans = 64'hC00001000000001D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2102949\n"); + end + x = 64'h434FFFFF77FFFFFE; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h036FFFDFBFFFFFFF; + ans = 64'h400FFFFF77FFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2103563\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h40300000000401FE; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2104177\n"); + end + x = 64'h802FFEDFFFFFFFFF; + y = 64'h7FE8008000000000; + z = 64'h3E1FFFFFFFF08000; + ans = 64'hC027FFA7FB6FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2104791\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h0000000000000000; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2105405\n"); + end + x = 64'hB13FF9FFFFFFFFFF; + y = 64'h7FEB577402A3C99B; + z = 64'hC000000000000001; + ans = 64'hF13B52539CE34AE4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2106019\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hC340000000400002; + ans = 64'hC340000000400000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2106633\n"); + end + x = 64'hBEB000000081FFFE; + y = 64'h28400200000FFFFE; + z = 64'h0006905A4202FB7C; + ans = 64'hA70002000092103C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2107247\n"); + end + x = 64'h49BFFFFFFC07FFFF; + y = 64'h3FE0000000000001; + z = 64'h3CA0000000000001; + ans = 64'h49AFFFFFFC080001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2107861\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h4027153765463EB7; + z = 64'hBFF0401FFFFFFFFF; + ans = 64'h4056D436E5463EB6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2108475\n"); + end + x = 64'hD4B000007FBFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3FBFFFE000000000; + ans = 64'hD4B000007FBFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2109089\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC4D333B83E26FA35; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2109703\n"); + end + x = 64'hDF80000000840000; + y = 64'hC0F65C25999F8D14; + z = 64'h3CA0080003FFFFFE; + ans = 64'h60865C259A58054A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2110317\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h3FF0000000000000; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2110931\n"); + end + x = 64'h802A7CAC07CCC888; + y = 64'h3B3FFDFFFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2111545\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hB59388B135C6AA9F; + ans = 64'h402FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2112159\n"); + end + x = 64'h80200000100000FF; + y = 64'hB500000000001000; + z = 64'hBFF9A6A59DDDCA4B; + ans = 64'hBFF9A6A59DDDCA4B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2112773\n"); + end + x = 64'hC1EFFFFF800007FF; + y = 64'h4000000000000000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hC1FFFFFF800007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2113387\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h7FDEDBBC8C149E63; + z = 64'h3DE00000047FFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2114001\n"); + end + x = 64'hC80FFFFFC0000007; + y = 64'h4000000000000001; + z = 64'h000F69ED724B3CE0; + ans = 64'hC81FFFFFC0000009; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2114615\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h3FA400000003FFFF; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2115229\n"); + end + x = 64'h43D1000000000007; + y = 64'h3F80007FF7FFFFFF; + z = 64'h43E00000000007F7; + ans = 64'h43E0110087F787F7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2115843\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2116457\n"); + end + x = 64'hF0FEFF7FFFFFFFFF; + y = 64'h41C00007FFFF8000; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hF2CEFF8F7FBF0803; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2117071\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h4010000000000001; + z = 64'hC050FFFFFFFF0000; + ans = 64'hC041FFFFFFFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2117685\n"); + end + x = 64'hC010D92032C10045; + y = 64'h62F00000FFFFFFFF; + z = 64'hC01FFC0000000002; + ans = 64'hE310D92140530370; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2118299\n"); + end + x = 64'h42FFF00000001000; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h432FF00000000FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2118913\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC34ECB4086F52F1D; + z = 64'h4A3FF3FFFFFFFFFE; + ans = 64'h4A3FF3FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2119527\n"); + end + x = 64'h41F10001FFFFFFFF; + y = 64'h4340000000000000; + z = 64'hE7D000000800FFFF; + ans = 64'hE7D000000800FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2120141\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC03F62D036C48204; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'hC06E62D036C48203; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2120755\n"); + end + x = 64'hC3D00000FFFFFFFB; + y = 64'hC1DFFFFFFE3FFFFF; + z = 64'h7FEFFFFFFFEF8000; + ans = 64'h7FEFFFFFFFEF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2121369\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'h437BFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2121983\n"); + end + x = 64'hC00FF00000007FFF; + y = 64'h3EF0200000000FFF; + z = 64'hBFE0000000000000; + ans = 64'hBFE00080BF800003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2122597\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'h3FEFEFFFFFBFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2123211\n"); + end + x = 64'h8008000004000000; + y = 64'h41DB7E58A68A6ECF; + z = 64'h41C46835257E7DE1; + ans = 64'h41C46835257E7DE1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2123825\n"); + end + x = 64'h80236BC873359E39; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h0000000000000000; + ans = 64'hC0236BC873359E38; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2124439\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h4C40005FFFFFFFFF; + z = 64'hC22FDFFFFC000000; + ans = 64'h4C70005FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2125053\n"); + end + x = 64'h43CF80000001FFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hC020000000F7FFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2125667\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hFFD4C24672F919D5; + z = 64'h4010000000000000; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -53664,12 +162798,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2297973\n"); + $fwrite(fp,"2126281\n"); end - x = 64'hBCA00007EFFFFFFF; - y = 64'h3F1000000000037F; - z = 64'h001000000040007E; - ans = 64'hBBC00007F000037E; + x = 64'h7FE0000800007FFE; + y = 64'hC350000200000002; + z = 64'hBFF0018000000000; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -53711,10 +162845,2454 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2299987\n"); + $fwrite(fp,"2126895\n"); end - x = 64'h4340000000000001; - y = 64'h0000000000000001; + x = 64'h401FFFFFFFFFFFFF; + y = 64'h7FF0000000000001; + z = 64'hC340000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2127509\n"); + end + x = 64'h7FE7FFFFFFFFFFDF; + y = 64'h0010002000007FFE; + z = 64'hBFD0000000000001; + ans = 64'h400600300000BFDC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2128123\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3FCFFFFF7FFFFFBE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2128737\n"); + end + x = 64'h400FF7DFFFFFFFFF; + y = 64'hBFF03EFFFFFFFFFE; + z = 64'h4FAEFFFFFFFFFFF8; + ans = 64'h4FAEFFFFFFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2129351\n"); + end + x = 64'hBE4001000000007F; + y = 64'h8000000000000000; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2129965\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h3800003FFFFFFDFE; + z = 64'hD1C07FFFFDFFFFFF; + ans = 64'hD1C07FFFFDFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2130579\n"); + end + x = 64'h43407FF7FFFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC1EFFFFFFBFF7FFF; + ans = 64'hC1EFFFFFFBFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2131193\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC028D8C773920EEF; + z = 64'h4000000000000001; + ans = 64'hC05858C773920EEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2131807\n"); + end + x = 64'hD6DF800010000000; + y = 64'h369E6917CE8CD5B8; + z = 64'hFFE00007FFFFF7FE; + ans = 64'hFFE00007FFFFF7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2132421\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h8010000000000000; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2133035\n"); + end + x = 64'h686003FF00000000; + y = 64'h400FFFFFF0000400; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h688003FEF7FE0280; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2133649\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hC7EFFFFF0000007F; + ans = 64'hC7EFFFFF0000007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2134263\n"); + end + x = 64'hAA0FFFFF80003FFE; + y = 64'hC7EFFF00007FFFFF; + z = 64'h3FC00000203FFFFF; + ans = 64'h3FC00000203FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2134877\n"); + end + x = 64'hC1CF7FFFFFFFFFFC; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2135491\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h47E0BD1B124969B2; + z = 64'h40201FFFFFFFFFBE; + ans = 64'h4810BD1B124969B1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2136105\n"); + end + x = 64'h0010000010000080; + y = 64'hBCA0000000000001; + z = 64'h3B8D00D9D4D54E0A; + ans = 64'h3B8D00D9D4D54E0A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2136719\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hB7F00000800003FF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2137333\n"); + end + x = 64'h41EFFFFFE01FFFFF; + y = 64'hFFEFF7FFFF800000; + z = 64'hFFFD03ECB3953DAA; + ans = 64'hFFFD03ECB3953DAA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2137947\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2138561\n"); + end + x = 64'h3FE61D66F271C086; + y = 64'hC3F00000400000FE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hC3E61D674AE75DAF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2139175\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hBFD0000000000001; + z = 64'h800B3DE08741C4C4; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2139789\n"); + end + x = 64'hB81C0000001FFFFF; + y = 64'hB8486203813E1F77; + z = 64'h12C0000000400008; + ans = 64'h307555C3112EBD8B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2140403\n"); + end + x = 64'hBFC0200000003FFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2141017\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h3CAFFFF80FFFFFFF; + z = 64'h47220007FFFFFFFF; + ans = 64'h47220007FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2141631\n"); + end + x = 64'h61FFFFF003FFFFFF; + y = 64'hBFE0000000000000; + z = 64'h43E0000001FFFFF6; + ans = 64'hE1EFFFF003FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2142245\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC3DFFFFFF0000007; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'hC40FFFFFF0000006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2142859\n"); + end + x = 64'hB7F000001FFFFFFF; + y = 64'hC0EFFFFFFFFFC006; + z = 64'h7FEFFC00000FFFFF; + ans = 64'h7FEFFC00000FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2143473\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hC023FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2144087\n"); + end + x = 64'h001FFFFFF80007FE; + y = 64'hCA8000040000FFFE; + z = 64'h8010000000000000; + ans = 64'h8AB00003FC0102FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2144701\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hBFF0000000000000; + z = 64'h41F0007FFFFFFFFC; + ans = 64'h41F0007FFF7FFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2145315\n"); + end + x = 64'hC800080000003FFF; + y = 64'h40DFFFFFFFFF7FE0; + z = 64'hBFFFFFFFFFFFFF0F; + ans = 64'hC8F007FFFFFFFFCF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2145929\n"); + end + x = 64'h49D0008000001FFF; + y = 64'hBFF0000000000001; + z = 64'hC340000000000000; + ans = 64'hC9D0008000002000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2146543\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC7F8000000000002; + z = 64'h3FEFFFFFFFFFFFBB; + ans = 64'hC828000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2147157\n"); + end + x = 64'hAC48000000000007; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hC020000000040003; + ans = 64'hC020000000040003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2147771\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC1C7FFFF7FFFFFFF; + z = 64'h3FE0000000000000; + ans = 64'hC1F7FFFF7FF7FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2148385\n"); + end + x = 64'hBC0007FFFE000000; + y = 64'h8005B72E93CFC238; + z = 64'hB1440CD30F8D6060; + ans = 64'hB1440CD30F8D6060; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2148999\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC000000000000001; + z = 64'hBFF0000000000000; + ans = 64'hC031000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2149613\n"); + end + x = 64'h3F8FE0007FFFFFFF; + y = 64'h2E710000000001FF; + z = 64'h8000000000000001; + ans = 64'h2E10EF00440001FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2150227\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h43F0080000000008; + ans = 64'h43F0080000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2150841\n"); + end + x = 64'h3FF0040000080000; + y = 64'h4F30F7CEC7A64330; + z = 64'h5910E7DF0960199B; + ans = 64'h5910E7DF0960199B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2151455\n"); + end + x = 64'h3FBF800003FFFFFE; + y = 64'hC010000000000000; + z = 64'hC010000000000001; + ans = 64'hC011F80000400001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2152069\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC01FFFFEDFFFFFFE; + z = 64'h41D0000FDFFFFFFF; + ans = 64'h41D0000FD000008F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2152683\n"); + end + x = 64'hC090001FFF000000; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hC010000001FFFFE0; + ans = 64'h40BFFC3FFDFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2153297\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h414DFFFFFFFDFFFE; + z = 64'h3FD0000000000001; + ans = 64'h417E000003FDFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2153911\n"); + end + x = 64'hADF0000000000101; + y = 64'h47FFFFBFFFFFFFEE; + z = 64'h768FFFEFFFFFFDFF; + ans = 64'h768FFFEFFFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2154525\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC340000000000000; + z = 64'hBFE0000000000001; + ans = 64'hC36FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2155139\n"); + end + x = 64'h40C000000007FFFA; + y = 64'h43CFFFFFFBFFFFDF; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2155753\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hCEDFFFFFD0000000; + ans = 64'hCEDFFFFFD0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2156367\n"); + end + x = 64'hC030001FF0000000; + y = 64'h24600023FFFFFFFF; + z = 64'hC1DFFFBFFFFF7FFF; + ans = 64'hC1DFFFBFFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2156981\n"); + end + x = 64'hB9E00FFFFFFFF800; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2157595\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC34FFFFFFFF20000; + z = 64'h4034001FFFFFFFFE; + ans = 64'hC37FFFFFFFF1FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2158209\n"); + end + x = 64'hC3CFFFFFBFFDFFFF; + y = 64'hFFE0000000000001; + z = 64'h4D70400000000FFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2158823\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h001B5645AEF74677; z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; @@ -53758,12 +165336,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2302001\n"); + $fwrite(fp,"2159437\n"); end - x = 64'h7FE3795AF4A2B560; - y = 64'h000FFFFFFFFFFFFE; - z = 64'h0020008000200000; - ans = 64'h4003795AF4A2B55E; + x = 64'h434C0975C90677C8; + y = 64'h380FF0000000001F; + z = 64'hB7F11D571313021E; + ans = 64'h3B6BFB710E21F4A7; rn = 1; rz = 0; rm = 0; @@ -53805,12 +165383,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2304015\n"); + $fwrite(fp,"2160051\n"); end - x = 64'h434F8DA321556224; - y = 64'hC01B2588E50183BE; - z = 64'h427142EFD04A8C6B; - ans = 64'hC37AC473219328A3; + x = 64'h401FFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -53852,12 +165430,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2306029\n"); + $fwrite(fp,"2160665\n"); end - x = 64'h4340000000000001; - y = 64'h3CA0000000000000; - z = 64'hBFF0000000000001; - ans = 64'h0000000000000000; + x = 64'h3FC1FFFFFFE00000; + y = 64'h3FB2000000000003; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -53899,12 +165477,858 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2308043\n"); + $fwrite(fp,"2161279\n"); end - x = 64'h00114508BDE544E1; + x = 64'h401FFFFFFFFFFFFF; + y = 64'hFFF0000000000001; + z = 64'hC3D3FFFFFFE00000; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2161893\n"); + end + x = 64'hC3F00000011FFFFF; + y = 64'hCC3FFFFFFFFFE00E; + z = 64'hA29FFFFFFFFFF7FE; + ans = 64'h50400000011FF006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2162507\n"); + end + x = 64'hC3D4800000000000; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2163121\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hFFD0D5461AB97F96; + z = 64'h41CB0920A36D44D9; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2163735\n"); + end + x = 64'h41FFF7FFFFFFFFDE; + y = 64'h0000000000000000; + z = 64'hE76A841E3E18C6FF; + ans = 64'hE76A841E3E18C6FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2164349\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h41E020000007FFFF; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h421020000007FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2164963\n"); + end + x = 64'hC3FE4FBC9B42F5B4; + y = 64'h40200080000007FE; + z = 64'hB80FF7FFFFDFFFFF; + ans = 64'hC42E50AF1927DEF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2165577\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2166191\n"); + end + x = 64'h480BCB365F69F57F; + y = 64'h40738DF7B187116B; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2166805\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h0010000000000000; + z = 64'hC000070A5DABB9D0; + ans = 64'hC000070A5DABB9D0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2167419\n"); + end + x = 64'h2CC928717C7B85D4; + y = 64'hBE37BC475F020AD5; + z = 64'h41EFFFFFFFFEFDFF; + ans = 64'h41EFFFFFFFFEFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2168033\n"); + end + x = 64'hBFC144B4875A348D; + y = 64'h0010000000000001; + z = 64'hBFF0000000000000; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2168647\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h2840000080000000; + z = 64'h4030922251CA0B50; + ans = 64'h4030922251CA0B50; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2169261\n"); + end + x = 64'h402FFFFBFF7FFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hF8CFFE007FFFFFFF; + ans = 64'hF8CFFE007FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2169875\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC0FBFFFFFFFFFFF0; + z = 64'h0010000000000000; + ans = 64'hC12BFFFFFFFFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2170489\n"); + end + x = 64'hC500000800800000; + y = 64'h41FFFFFFFFBFFFFC; + z = 64'hB80BD40508FA289F; + ans = 64'hC7100008005FFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2171103\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h3CA0000000000001; + z = 64'hBCA0000000000000; + ans = 64'h3CCC000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2171717\n"); + end + x = 64'h3CA0000080000FFE; + y = 64'h380DFFFF00000000; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2172331\n"); + end + x = 64'h401FFFFFFFFFFFFE; y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h800010000003FFFE; - ans = 64'h800010000003FFFD; + z = 64'h000FFFFDFFFFEFFF; + ans = 64'h3CDFFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -53946,12 +166370,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2310057\n"); + $fwrite(fp,"2172945\n"); end - x = 64'h4000001000000020; - y = 64'hC1F1000000000004; - z = 64'h6A4FFFFFFFDFFFF7; - ans = 64'h6A4FFFFFFFDFFFF7; + x = 64'hC3F000000003FF00; + y = 64'h405BFFFFFE000000; + z = 64'h3FAFFFFFFFFE1FFF; + ans = 64'hC45BFFFFFE06FE40; rn = 1; rz = 0; rm = 0; @@ -53993,12 +166417,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2312071\n"); + $fwrite(fp,"2173559\n"); end - x = 64'h4340000000000001; + x = 64'hBFD911DFB7F9CEDD; + y = 64'h3FD0000000000000; + z = 64'hBFE0000000000001; + ans = 64'hBFE3223BF6FF39DD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2174173\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h32EFFFFFF7F7FFFF; + z = 64'hC800000000FFFFC0; + ans = 64'hC800000000FFFFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2174787\n"); + end + x = 64'hBF0FFFFF10000000; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hC950000BFFFFFFFF; + ans = 64'hC950000BFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2175401\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC0E00100000001FE; + z = 64'h0000000000000001; + ans = 64'hC1100100000001FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2176015\n"); + end + x = 64'hC1FFFDFFFFF80000; + y = 64'h40AFFC000000003E; + z = 64'h7FD69A1CC85982DA; + ans = 64'h7FD69A1CC85982DA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2176629\n"); + end + x = 64'h401FFFFFFFFFFFFE; y = 64'h3FE0000000000000; - z = 64'h4340000000000000; - ans = 64'h4348000000000000; + z = 64'h8010000000000001; + ans = 64'h400FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -54040,12 +166699,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2314085\n"); + $fwrite(fp,"2177243\n"); end - x = 64'hBFD0000000004FFF; + x = 64'hBC30400000FFFFFE; + y = 64'hC02FFFBFF7FFFFFF; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2177857\n"); + end + x = 64'h401FFFFFFFFFFFFE; y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hB570000003FFFEFE; - ans = 64'hBFD0000000004FFE; + z = 64'h41FFFFFB7FFFFFFF; + ans = 64'h41FFFFFB807FFFFF; rn = 1; rz = 0; rm = 0; @@ -54087,12 +166793,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2316099\n"); + $fwrite(fp,"2178471\n"); end - x = 64'h3F8B17D321454789; - y = 64'h3FD7FFFFFFFFFF7F; - z = 64'hBFE000080FFFFFFE; - ans = 64'hBFDFAEC8A69C3027; + x = 64'hBFE3DC34614FE233; + y = 64'h407F3395996D3BDD; + z = 64'h000FFFFFFFFFFFF5; + ans = 64'hC0735D568A4D0539; rn = 1; rz = 0; rm = 0; @@ -54134,12 +166840,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2318113\n"); + $fwrite(fp,"2179085\n"); end - x = 64'h4340000000000001; + x = 64'h43EA1727CA3DE0E5; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h43EA1727CA3DE0E3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2179699\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hBE2E7FFFFFFFFFFF; + z = 64'h3FE0101FFFFFFFFF; + ans = 64'h3FE0101FF0BFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2180313\n"); + end + x = 64'h41F352E0B6A41A6F; + y = 64'h3FF0000000000001; + z = 64'hC3F1FFFFFFFFF7FE; + ans = 64'hC3F1FFFFFFECA51D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2180927\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hBF139BBEA43347D1; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2181541\n"); + end + x = 64'hC03D8D9F3E07CDB5; + y = 64'h434FFFFFFE07FFFF; + z = 64'hBF15743D92475450; + ans = 64'hC39D8D9F3C365728; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2182155\n"); + end + x = 64'h401FFFFFFFFFFFFE; y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h402FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -54181,12 +167122,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2320127\n"); + $fwrite(fp,"2182769\n"); end - x = 64'h3FB0008020000000; + x = 64'h380733B41F678237; + y = 64'h3FF00000207FFFFF; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2183383\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h4000000000000001; + z = 64'hC7F001FFFFFFFF80; + ans = 64'hC7F001FFFFFFFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2183997\n"); + end + x = 64'h38130C2AD3A6C0EA; + y = 64'h40100001000001FF; + z = 64'hB80FFDFFFFFBFFFF; + ans = 64'h382E18D808D3E10A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2184611\n"); + end + x = 64'hC6DFFFFFFFFFFF03; y = 64'h400FFFFFFFFFFFFF; - z = 64'h61EC0300875AF1DE; - ans = 64'h61EC0300875AF1DE; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hC6FFFFFFFFFFFF02; rn = 1; rz = 0; rm = 0; @@ -54228,12 +167310,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2322141\n"); + $fwrite(fp,"2185225\n"); end - x = 64'hBA800007FFDFFFFF; - y = 64'hC02FFFFEFFFFFFFF; - z = 64'hCB5005366E0E9CD9; - ans = 64'hCB5005366E0E9CD9; + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC1F6594B8FFA4BB7; + z = 64'h43C2000000000007; + ans = 64'h43C1FFFFFA69AD23; rn = 1; rz = 0; rm = 0; @@ -54275,12 +167357,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2324155\n"); + $fwrite(fp,"2185839\n"); end - x = 64'h4340000000000001; - y = 64'h401FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h4370000000000000; + x = 64'h3FC00000001E0000; + y = 64'h4010000000000000; + z = 64'h7B6FFFBFFFFDFFFF; + ans = 64'h7B6FFFBFFFFDFFFF; rn = 1; rz = 0; rm = 0; @@ -54322,12 +167404,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2326169\n"); + $fwrite(fp,"2186453\n"); end - x = 64'h47B0001FFFDFFFFF; - y = 64'h434FFFFFFFFFFFFF; - z = 64'h3F0FFFFFFFFFFFD7; - ans = 64'h4B10001FFFDFFFFE; + x = 64'h401FFFFFFFFFFFFE; + y = 64'h63DFFEFFFFFFF7FF; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -54369,12 +167451,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2328183\n"); + $fwrite(fp,"2187067\n"); end - x = 64'h3FF0078000000000; - y = 64'h42B13867492E71C0; - z = 64'hC15FFFFFFC0000FE; - ans = 64'h42B140793998BF95; + x = 64'h43AFFFFFFFFFFC02; + y = 64'h3E600000002000FF; + z = 64'hC1EFFFFFFFE3FFFF; + ans = 64'h421C000000437E00; rn = 1; rz = 0; rm = 0; @@ -54416,11 +167498,434 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2330197\n"); + $fwrite(fp,"2187681\n"); end - x = 64'h4340000000000001; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; + x = 64'h401FFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2188295\n"); + end + x = 64'hBEEFFFFC000000FF; + y = 64'hC34F7FFFFFFF7FFF; + z = 64'h4000000000000000; + ans = 64'h424F7FFC100080FA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2188909\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h4340000000000000; + z = 64'hC25D8DAAFC9DDB29; + ans = 64'h436FFFF1392A81AF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2189523\n"); + end + x = 64'hC0E000002FFFFFFF; + y = 64'hC00FBFFFBFFFFFFE; + z = 64'h0AEFFFFF7EFFFFFF; + ans = 64'h40FFC0001F3FFF3C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2190137\n"); + end + x = 64'h4A104315AC3EB886; + y = 64'h4340000000000001; + z = 64'hBCA0000000000000; + ans = 64'h4D604315AC3EB887; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2190751\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC7407FFFFFFFFFFB; + z = 64'hC011FFFEFFFFFFFE; + ans = 64'hC7707FFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2191365\n"); + end + x = 64'hC7FFC00080000000; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hBFB0000004007FFF; + ans = 64'hCB5FC0007FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2191979\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h403FBFFFFFFFFE00; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2192593\n"); + end + x = 64'h4032000000003FFF; + y = 64'h3FBFFFFFBFFFFFDF; + z = 64'hBD50007FFF000000; + ans = 64'h4001FFFFDC003DEC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2193207\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'h7FF0000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -54463,12 +167968,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2332211\n"); + $fwrite(fp,"2193821\n"); end - x = 64'h403F840000000000; - y = 64'h7FF0000000000001; - z = 64'h47E00FFFFFFE0000; - ans = 64'h7FF8000000000001; + x = 64'h3FEFFDFFFFFF8000; + y = 64'h0005C9224A1E956A; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; rn = 1; rz = 0; rm = 0; @@ -54510,12 +168015,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2334225\n"); + $fwrite(fp,"2194435\n"); end - x = 64'hC1EFFFFFFBFFFFBF; - y = 64'h41EFF99F4885A23D; - z = 64'hC3CFFFE000000001; - ans = 64'hC3F3FCCBA243370A; + x = 64'h401FFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h3F8001000000FFFE; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -54557,12 +168062,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2336239\n"); + $fwrite(fp,"2195049\n"); end - x = 64'h4340000000000001; - y = 64'h800FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + x = 64'hC03FFFFFFEFFFFF0; + y = 64'hB9CFC0000000007F; + z = 64'hBFEB1648C4E67458; + ans = 64'hBFEB1648C4E67458; rn = 1; rz = 0; rm = 0; @@ -54604,12 +168109,529 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2338253\n"); + $fwrite(fp,"2195663\n"); end - x = 64'h3808AD94B0AE8803; + x = 64'hBEBFFFFFFFF7F7FF; + y = 64'h7FF0000000000000; + z = 64'h8010000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2196277\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h820000FFFFFFFFFB; + z = 64'h37FFFFFFFFF7FEFE; + ans = 64'h37FFFFFFFFF7FEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2196891\n"); + end + x = 64'h7E20BFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h3D500000000FBFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2197505\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h28AFBFFFFFFFFFFE; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2198119\n"); + end + x = 64'h3064B981E97CBA0F; + y = 64'h5D5FFFFFFFFF01FF; + z = 64'h0020004000000001; + ans = 64'h4DD4B981E97C158E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2198733\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h8000000000000000; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2199347\n"); + end + x = 64'h801007FFFBFFFFFF; + y = 64'hC030000400000400; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2199961\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h8000000000000001; + z = 64'hBBB9E662CC81018C; + ans = 64'hBBB9E662CC81018C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2200575\n"); + end + x = 64'hC54002000003FFFF; + y = 64'h3E02EC0486B0BE36; + z = 64'h3FD0403FFFFFFFFE; + ans = 64'hC352EE6207464F4E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2201189\n"); + end + x = 64'h41FFFFFF80000200; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h821FFFFF801001FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2201803\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC1E00043FFFFFFFE; + z = 64'hB7EFE0000000007E; + ans = 64'hC2100043FFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2202417\n"); + end + x = 64'h401007FFEFFFFFFF; y = 64'h8010000000000001; - z = 64'h40E00100000007FF; - ans = 64'h40E00100000007FF; + z = 64'hC7EF672408576C70; + ans = 64'hC7EF672408576C70; rn = 1; rz = 0; rm = 0; @@ -54651,12 +168673,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2340267\n"); + $fwrite(fp,"2203031\n"); end - x = 64'h43D4346A89A9C97B; - y = 64'hBFFBFFFFFFFFFFBF; - z = 64'hFFF959CBE947EE04; - ans = 64'hFFF959CBE947EE04; + x = 64'h401FFFFFFFFFFFFE; + y = 64'h40400007FFEFFFFE; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'h406F000FFFDFFFFA; rn = 1; rz = 0; rm = 0; @@ -54698,9 +168720,244 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2342281\n"); + $fwrite(fp,"2203645\n"); end - x = 64'h4340000000000001; + x = 64'hC3848D211BED45F4; + y = 64'h41C40000000FFFFF; + z = 64'hC770000000407FFF; + ans = 64'hC77000000046EC19; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2204259\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2204873\n"); + end + x = 64'h0E2000207FFFFFFE; + y = 64'hBCCFFFF6FFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2205487\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hBCA0000000000000; + z = 64'hC01EFFFFFFFFFFFE; + ans = 64'hC01EFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2206101\n"); + end + x = 64'h37EE0000003FFFFF; + y = 64'hFFEFFFF600000000; + z = 64'hBFCFEFFEFFFFFFFF; + ans = 64'hF7EDFFF6A03FFFEB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2206715\n"); + end + x = 64'hC050020000000FFF; y = 64'hBCAFFFFFFFFFFFFF; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; @@ -54745,12 +169002,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2344295\n"); + $fwrite(fp,"2207329\n"); end - x = 64'h26986A27B483BA39; - y = 64'hBFD0000000000001; - z = 64'h4030000000000700; - ans = 64'h4030000000000700; + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC3400003FFFFFFFD; + z = 64'h37F0001000000002; + ans = 64'hC3700003FFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -54792,12 +169049,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2346309\n"); + $fwrite(fp,"2207943\n"); end - x = 64'hCA7FFF0000000FFF; - y = 64'h3CA62FD739ECE5A5; - z = 64'h48000000003F0000; - ans = 64'h47FFFE9D0E224CCE; + x = 64'hBFC0000001BFFFFF; + y = 64'hBFD0000000000000; + z = 64'h37F104AA7323DE0F; + ans = 64'h3FA0000001BFFFFF; rn = 1; rz = 0; rm = 0; @@ -54839,12 +169096,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2348323\n"); + $fwrite(fp,"2208557\n"); end - x = 64'h4340000000000001; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC340000000000000; + x = 64'h401FFFFFFFFFFFFE; + y = 64'h8000001FFF800000; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -54886,12 +169143,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2350337\n"); + $fwrite(fp,"2209171\n"); end - x = 64'hCECBF0857C72A5F5; - y = 64'hBFF0000000000000; - z = 64'hBCE01000FFFFFFFF; - ans = 64'h4ECBF0857C72A5F5; + x = 64'h3EEFEAB58D93A8FE; + y = 64'hB7FFFFFFFFFFE03E; + z = 64'h3FF0000000001F7E; + ans = 64'h3FF0000000001F7E; rn = 1; rz = 0; rm = 0; @@ -54933,12 +169190,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2352351\n"); + $fwrite(fp,"2209785\n"); end - x = 64'h43D003FFFFFFFFEF; - y = 64'h37F0800000000080; - z = 64'h4050200000003FFE; - ans = 64'h4050200000003FFE; + x = 64'h401FFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -54980,12 +169237,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2354365\n"); + $fwrite(fp,"2210399\n"); end - x = 64'h4340000000000001; - y = 64'hC000000000000001; - z = 64'hBFF0000000000001; - ans = 64'hC350000000000002; + x = 64'h400BE6A8C346FFA8; + y = 64'h381F7FFFFFFFFFFE; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; rn = 1; rz = 0; rm = 0; @@ -55027,12 +169284,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2356379\n"); + $fwrite(fp,"2211013\n"); end - x = 64'hC00FFBFDFFFFFFFE; - y = 64'hC010000000000000; - z = 64'h3EEF7BB95B77143E; - ans = 64'h402FFBFFF7BB95B5; + x = 64'h401FFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBD60000080008000; + ans = 64'hC0100000000001FE; rn = 1; rz = 0; rm = 0; @@ -55074,12 +169331,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2358393\n"); + $fwrite(fp,"2211627\n"); end - x = 64'hFFDDD23FE56E05F5; - y = 64'h41E008003FFFFFFF; - z = 64'hBF4BB3E839E09DEE; - ans = 64'hFFF0000000000000; + x = 64'h3FFFFFFFF0000000; + y = 64'h3FC4000000000FFE; + z = 64'hBFFFFFFFFFFFFFF9; + ans = 64'hBFFB0000027FFBFA; rn = 1; rz = 0; rm = 0; @@ -55121,904 +169378,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2360407\n"); + $fwrite(fp,"2212241\n"); end - x = 64'h4340000000000001; - y = 64'hC340000000000001; - z = 64'h4340000000000000; - ans = 64'hC690000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2362421\n"); - end - x = 64'hF29DFFFFFFBFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h3FDFFFFC1FFFFFFF; - ans = 64'h75FDFFFFFFBFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2364435\n"); - end - x = 64'hC531EAD9646C686E; - y = 64'hB97FFFFFF80001FF; - z = 64'h89CFFFFFC0003FFF; - ans = 64'h3EC1EAD95FF1B333; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2366449\n"); - end - x = 64'h4340000000000001; - y = 64'hFFF0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2368463\n"); - end - x = 64'h3FE00000000C0000; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h40400000007FFFFB; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2370477\n"); - end - x = 64'h7FEFFFFFFF9FFFFF; - y = 64'hBA60000000FFFFDF; - z = 64'h3FFFBFFBFFFFFFFF; - ans = 64'hFA60000000CFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2372491\n"); - end - x = 64'h434FFFFFFFFFFFFF; - y = 64'h0010000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2374505\n"); - end - x = 64'h401385F7A9AF5663; - y = 64'h001FFFFFFFFFFFFE; - z = 64'hC0D00000003FFF7F; - ans = 64'hC0D00000003FFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2376519\n"); - end - x = 64'hC03FFFE07FFFFFFE; - y = 64'hC0C87EC3854317EF; - z = 64'hC23400016ADF210A; - ans = 64'hC233FFFB4B3446EB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2378533\n"); - end - x = 64'h434FFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h4330000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2380547\n"); - end - x = 64'hBFD0003FFFFFFFBF; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'hC800000000003F7F; - ans = 64'hC800000000003F7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2382561\n"); - end - x = 64'h3CA02000000001FF; - y = 64'h7FDFFF8000020000; - z = 64'h3B052E2A4593433B; - ans = 64'h7C901FBF800103FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2384575\n"); - end - x = 64'h434FFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'h433FFFFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2386589\n"); - end - x = 64'hC1F0001FFFFF7FFE; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h4020000000043FFF; - ans = 64'hC200001FFFBF7FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2388603\n"); - end - x = 64'h40BFFFFFFFFFFFFF; - y = 64'hB7AFFFEFFDFFFFFF; - z = 64'hBFCFFC0000007FFF; - ans = 64'hBFCFFC0000007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2390617\n"); - end - x = 64'h434FFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2392631\n"); - end - x = 64'hE53B5D1CE7BB1B34; - y = 64'h401FFFFFFFFFFFFF; - z = 64'hC800800000000100; - ans = 64'hE56B5D1CE7BB1B33; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2394645\n"); - end - x = 64'h42A0020000000007; - y = 64'hBDAFE01FFFFFFFFF; - z = 64'h3FF000000021FFFF; - ans = 64'hC05FA41C03FF780D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2396659\n"); - end - x = 64'h434FFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h46AFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2398673\n"); - end - x = 64'h40469EBFECE9387D; - y = 64'h7FE0000000000001; - z = 64'h381C686C04250688; + x = 64'h41D0000000000807; + y = 64'hBFE0000000000001; + z = 64'h7FF0000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -56061,12 +169425,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2400687\n"); + $fwrite(fp,"2212855\n"); end - x = 64'h400C1D1B46E04D2B; - y = 64'hBE4E00000000001F; - z = 64'hC02F7FFF00000000; - ans = 64'hC02F7FFF01A5B499; + x = 64'h401FFFFFFFFFFFFE; + y = 64'h3FDC01FFFFFFFFFE; + z = 64'hC3F0000401FFFFFE; + ans = 64'hC3F0000401FFFFFE; rn = 1; rz = 0; rm = 0; @@ -56108,12 +169472,482 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2402701\n"); + $fwrite(fp,"2213469\n"); end - x = 64'h434FFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; + x = 64'hC80F13ECC2137E16; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hFFEFFFF8000003FE; + ans = 64'hFFEFFFF8000003FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2214083\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC1EFFFFF80040000; + z = 64'hC000000000000000; + ans = 64'hC21FFFFF800BFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2214697\n"); + end + x = 64'hC000FFFF00000000; + y = 64'hBFC00000003FFF7F; + z = 64'h3FAFFFFFFFDFFBFF; + ans = 64'h3FD4FFFF003FFEF3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2215311\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hBFF0000000000001; + z = 64'h4010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2215925\n"); + end + x = 64'h48A03FFFFFFFBFFF; + y = 64'h4061FF7FFFFFFFFF; + z = 64'h3CA0000000000001; + ans = 64'h4912477DFFFFB800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2216539\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h40BFFFBFFFFFF7FF; + ans = 64'h40BFEFBFFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2217153\n"); + end + x = 64'h379ED1F6EA8D1110; + y = 64'hB810000000800100; + z = 64'h80203FFFF7FFFFFF; + ans = 64'hAFBED1F6EB83A2B4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2217767\n"); + end + x = 64'hC1C05A35ECCACC30; + y = 64'hC000000000000000; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2218381\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hBDD000000800000F; + z = 64'h3FCFFFC0001FFFFF; + ans = 64'h3FCFFFBFFF1FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2218995\n"); + end + x = 64'h43F000003FFFEFFF; + y = 64'hC000000000000001; + z = 64'h001FFFFFE000000E; + ans = 64'hC40000003FFFF000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2219609\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC1E0008000800000; z = 64'hBFF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; + ans = 64'hC21000800083FFFF; rn = 1; rz = 0; rm = 0; @@ -56155,12 +169989,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2404715\n"); + $fwrite(fp,"2220223\n"); end - x = 64'h4017FFFFBFFFFFFF; - y = 64'h8000000000000001; - z = 64'hFFDFFFDFFFFFF7FF; - ans = 64'hFFDFFFDFFFFFF7FF; + x = 64'h3FA00000000007C0; + y = 64'h41CFF7FFFFFF7FFE; + z = 64'h43CFFFFFFF8003FE; + ans = 64'h43CFFFFFFF8103BE; rn = 1; rz = 0; rm = 0; @@ -56202,12 +170036,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2406729\n"); + $fwrite(fp,"2220837\n"); end - x = 64'hBC1C9A8F60BA2EC4; - y = 64'h413000000020FFFF; - z = 64'h3FE0000E00000000; - ans = 64'h3FE0000DFFFFF1B3; + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC010000000000000; + z = 64'h4000000000000001; + ans = 64'hC03DFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -56249,11 +170083,2173 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2408743\n"); + $fwrite(fp,"2221451\n"); end - x = 64'h434FFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - z = 64'h4340000000000000; + x = 64'hBFCFFFE0FFFFFFFF; + y = 64'h3FBBCBE88BA8381B; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hBF9BCBCD9E1EF0CF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2222065\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC010000000000001; + z = 64'h5030000FFFFFFBFF; + ans = 64'h5030000FFFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2222679\n"); + end + x = 64'h6105A870582F21FC; + y = 64'hC170001FBFFFFFFF; + z = 64'h8010000180000000; + ans = 64'hE285A89B526E10F8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2223293\n"); + end + x = 64'h41DD898416FC5476; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFE2767BE8F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2223907\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h404FFFFFFFFFFCFF; + z = 64'h3FAFFEFFFFFFFFFC; + ans = 64'h4080007FFBFFFE7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2224521\n"); + end + x = 64'hC7FFFF80000001FE; + y = 64'hC340000000000000; + z = 64'h411FFFFFFFF7FFDE; + ans = 64'h4B4FFF80000001FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2225135\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h8000C97BEE00D34B; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2225749\n"); + end + x = 64'h62FFFFFFF1000000; + y = 64'h3873FFFFFFFFFF80; + z = 64'h24AFBFFFFFFFDFFF; + ans = 64'h5B83FFFFF69FFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2226363\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'hC37FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2226977\n"); + end + x = 64'h304003FFBFFFFFFF; + y = 64'h3FE2FABF1F6AD441; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h3032FF7D8347B277; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2227591\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hFFE0000000000000; + z = 64'hA3D00000000FFFFA; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2228205\n"); + end + x = 64'hFFFFFFBFF0000000; + y = 64'h4BFFFFFFBFFFFFC0; + z = 64'h40F007F7FFFFFFFF; + ans = 64'hFFFFFFBFF0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2228819\n"); + end + x = 64'hBFC000004000000E; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h7FC000004000000D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2229433\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hAE3FFFFFFFEFFFFF; + z = 64'h400FFFFFFFE0FFFF; + ans = 64'h400FFFFFFFE0FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2230047\n"); + end + x = 64'h47F00FFFFFFBFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h3FAFFFFFBFFFFFFC; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2230661\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC02FFF9FFFFFFFFE; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hC0600FCFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2231275\n"); + end + x = 64'hC348A49D10BEDDE4; + y = 64'h400276F4846B6206; + z = 64'h68D007FFFFFFFFDF; + ans = 64'h68D007FFFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2231889\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2232503\n"); + end + x = 64'hB8011C56478F348C; + y = 64'h403FFFEFFFFE0000; + z = 64'h0000000000000000; + ans = 64'hB8511C4DB962FEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2233117\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hBFEFFFFFF0000000; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2233731\n"); + end + x = 64'h3FC11A069589BC39; + y = 64'h3FCF800000004000; + z = 64'h40334BF615A75C67; + ans = 64'h40335460E4E4F643; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2234345\n"); + end + x = 64'h41900000200001FF; + y = 64'h0000000000000001; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2234959\n"); + end + x = 64'h4340000000000000; + y = 64'hBFF47A6831A030F5; + z = 64'hC34000000007FFFB; + ans = 64'hC3523D3418D41878; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2235573\n"); + end + x = 64'h2BB4FBFBC886F231; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3CA5AB28C6CBDEAA; + ans = 64'h3CA5AB28C6CBDEAA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2236187\n"); + end + x = 64'h4340000000000000; + y = 64'hBCF758AF3B14EB32; + z = 64'hBFD0000000000000; + ans = 64'hC04778AF3B14EB32; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2236801\n"); + end + x = 64'hC1F001FFFFFEFFFF; + y = 64'h480ADA0454848A3E; + z = 64'h43EFFFFC0000001F; + ans = 64'hCA0ADD5F950D6D2D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2237415\n"); + end + x = 64'h4340000000000000; + y = 64'h0010000000000001; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2238029\n"); + end + x = 64'hBFF5EF24C8F3E7E4; + y = 64'hC6B07FFFFE000000; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2238643\n"); + end + x = 64'h4340000000000000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h3FDFFFFFF7FFFF00; + ans = 64'h3FDFFFFFF7FFFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2239257\n"); + end + x = 64'hC02A9F0B59060CA0; + y = 64'h210FFFFFFFBBFFFE; + z = 64'hB810000000FFFF7F; + ans = 64'hB810000000FFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2239871\n"); + end + x = 64'hB7E000000000F000; + y = 64'h3CA0000000000000; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2240485\n"); + end + x = 64'h4340000000000000; + y = 64'h3D80001FFFEFFFFF; + z = 64'hC96FFFFFFFFBF800; + ans = 64'hC96FFFFFFFFBF800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2241099\n"); + end + x = 64'hBFC00000000101FF; + y = 64'h3CA0000000000001; + z = 64'hBF10000008000003; + ans = 64'hBF10000008000403; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2241713\n"); + end + x = 64'h4340000000000000; + y = 64'hBFC531280B222900; + z = 64'hBCA0000000000001; + ans = 64'hC31531280B222900; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2242327\n"); + end + x = 64'h3CA490ECEFD38623; + y = 64'h414FFFFBFFF7FFFF; + z = 64'hD120003FFFDFFFFE; + ans = 64'hD120003FFFDFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2242941\n"); + end + x = 64'h4340000000000000; + y = 64'h3FD0000000000000; + z = 64'h3FD0000000000001; + ans = 64'h4320000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2243555\n"); + end + x = 64'hC1D0003FFFF80000; + y = 64'hC7F0000000FEFFFE; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2244169\n"); + end + x = 64'h4340000000000000; + y = 64'h3FD0000000000001; + z = 64'hC5F79471ABFF5855; + ans = 64'hC5F79471ABFF57D5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2244783\n"); + end + x = 64'hC3C64F7F32A01115; + y = 64'h41D0001FFFBFFFFF; + z = 64'h43E00010000007FF; + ans = 64'hC5A64FABD0453757; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2245397\n"); + end + x = 64'h3FE8325AA8E5EF61; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h4003064B551CBDEB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2246011\n"); + end + x = 64'h4340000000000000; + y = 64'h4B220E85F7748991; + z = 64'h5D7BFF8C86E1490E; + ans = 64'h5D7BFF8C86E1490E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2246625\n"); + end + x = 64'h00009E4D8E813566; + y = 64'h3FE0000000000000; + z = 64'hC8000000001C0000; + ans = 64'hC8000000001C0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2247239\n"); + end + x = 64'h4340000000000000; + y = 64'h3FF00007FFFFFF00; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h43400007FFFFFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2247853\n"); + end + x = 64'h3D19EFC2065BEF14; + y = 64'hBFB0B74B5345ADF2; + z = 64'hC3D441E6C3A83622; + ans = 64'hC3D441E6C3A83622; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2248467\n"); + end + x = 64'h4340000000000000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h433FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2249081\n"); + end + x = 64'h37FFFFE000004000; + y = 64'h0010003EFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2249695\n"); + end + x = 64'h4340000000000000; + y = 64'h3FF0000000000000; + z = 64'h3FDC11549B9F5AA7; ans = 64'h4340000000000000; rn = 1; rz = 0; @@ -56296,528 +172292,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2410757\n"); + $fwrite(fp,"2250309\n"); end - x = 64'hC2400FFFFFFFFF7F; - y = 64'hBCA0000000000000; - z = 64'h4017FFFFFFFFFFF7; - ans = 64'h4018000403FFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2412771\n"); - end - x = 64'h7F600000FBFFFFFF; - y = 64'hC024153A49A4352E; - z = 64'hB2A0000000200002; - ans = 64'hFF94153B85F28B35; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2414785\n"); - end - x = 64'h434FFFFFFFFFFFFF; - y = 64'hBFD0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2416799\n"); - end - x = 64'hC1FFFFFFFFFF3FFF; - y = 64'hBFE0000000000000; - z = 64'hC01FFFFFFFE00000; - ans = 64'h41EFFFFFFEFF3FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2418813\n"); - end - x = 64'h3ECFFFFFFFFE0000; - y = 64'h3FC0FFF800000000; - z = 64'hC0D00010000007FE; - ans = 64'hC0D0000FFFFDE7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2420827\n"); - end - x = 64'h434FFFFFFFFFFFFF; - y = 64'hBFF0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC350000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2422841\n"); - end - x = 64'hBCC0103FFFFFFFFF; - y = 64'hC000000000000000; - z = 64'hB810010004000000; - ans = 64'h3CD0103FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2424855\n"); - end - x = 64'hBFDC000000080000; - y = 64'hBFBFFFFFFFFFEFE0; - z = 64'hC035EDB781F59599; - ans = 64'hC035DFB781F591A0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2426869\n"); - end - x = 64'h434FFFFFFFFFFFFF; - y = 64'hC010000000000001; - z = 64'h3FF0000000000001; - ans = 64'hC370000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2428883\n"); - end - x = 64'h00026CC69D542DC6; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h41F0000000000001; - ans = 64'h41F0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2430897\n"); - end - x = 64'h47BCAE5548D2EC6C; - y = 64'h8020FA9C6893D5B3; - z = 64'hC0300000000FFFBF; - ans = 64'hC0300000000FFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2432911\n"); - end - x = 64'h434FFFFFFFFFFFFF; - y = 64'hFFE0000000000000; - z = 64'hC340000000000000; + x = 64'h7FEA9F96DC0C28C0; + y = 64'hC010000000001BFF; + z = 64'hC7EFFFFFFFFFFFFE; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -56860,11 +172339,1092 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2434925\n"); + $fwrite(fp,"2250923\n"); end - x = 64'hC000731E440CDC60; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hF10FFFFFFFFFFE7F; + x = 64'h41FB29AFFFECD92D; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h420B29AFFFF4D92C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2251537\n"); + end + x = 64'h4340000000000000; + y = 64'hEBDFFDFF00000000; + z = 64'h413832D2DC13B5B9; + ans = 64'hEF2FFDFF00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2252151\n"); + end + x = 64'hC3D0000080001FFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h001EFFFFDFFFFFFF; + ans = 64'hC3E0000080001FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2252765\n"); + end + x = 64'h4340000000000000; + y = 64'h32540000000FFFFF; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h35A40000000FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2253379\n"); + end + x = 64'hB7EFFFFFFFF7FEFE; + y = 64'hBCCFE0FFFFFFFFFF; + z = 64'h403387575FCA1664; + ans = 64'h403387575FCA1664; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2253993\n"); + end + x = 64'h4340000000000000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h435FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2254607\n"); + end + x = 64'hC010000010007FFE; + y = 64'hD3C0000000800002; + z = 64'hC340000000000000; + ans = 64'h53E0000010808001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2255221\n"); + end + x = 64'h4340000000000000; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h40440FFFFFFFFFFE; + ans = 64'h4360000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2255835\n"); + end + x = 64'hC00C00F1226B2050; + y = 64'h3FFFFFDFFFFFFBFE; + z = 64'h37E0000000FDFFFF; + ans = 64'hC01C00D52179FA63; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2256449\n"); + end + x = 64'hCD7FFFFFFFFF7FFF; + y = 64'h4010000000000001; + z = 64'h3FE0000000000000; + ans = 64'hCD9FFFFFFFFF8001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2257063\n"); + end + x = 64'h4340000000000000; + y = 64'h55E00001FEFFFFFE; + z = 64'h3CAFBFFFFFDFFFFF; + ans = 64'h59300001FEFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2257677\n"); + end + x = 64'hC7FFFFFFFC01FFFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hC3EFF0007FFFFFFF; + ans = 64'hC82FFFFFFC01FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2258291\n"); + end + x = 64'h4340000000000000; + y = 64'h7FFFFFBFFFFEFFFF; + z = 64'h8000000000000000; + ans = 64'h7FFFFFBFFFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2258905\n"); + end + x = 64'hBF8FC0000FFFFFFE; + y = 64'hC02FFFFBFFF00000; + z = 64'hBFEFFFFFBFF00000; + ans = 64'hBFE81000B9F3F881; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2259519\n"); + end + x = 64'h4340000000000000; + y = 64'h4340000000000001; + z = 64'h0010000000000000; + ans = 64'h4690000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2260133\n"); + end + x = 64'hBFF0003FFF000000; + y = 64'hB13F48933B2117B6; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2260747\n"); + end + x = 64'h4340000000000000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h425975F42BB1D3BE; + ans = 64'h469FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2261361\n"); + end + x = 64'h43E000000000017E; + y = 64'hBC6FFFFF800003FF; + z = 64'hB81000004FFFFFFE; + ans = 64'hC05FFFFF800006FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2261975\n"); + end + x = 64'hC16FFBFFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'h3FD0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2262589\n"); + end + x = 64'h4340000000000000; + y = 64'hBCCFFFFFFE0007FF; + z = 64'h41DCB061BF22B973; + ans = 64'h41DCB061BD22B973; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2263203\n"); + end + x = 64'hB4400000000FFFFF; + y = 64'h7FE0000000000001; + z = 64'hC3476B9F80980CE3; + ans = 64'hF430000000100000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2263817\n"); + end + x = 64'h4340000000000000; + y = 64'hBFEF5455E66D6359; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2264431\n"); + end + x = 64'hC3D71608E45A0412; + y = 64'hC0180000001FFFFE; + z = 64'h6B0000FFFFFFFDFF; + ans = 64'h6B0000FFFFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2265045\n"); + end + x = 64'h4340000000000000; + y = 64'h7FF0000000000000; + z = 64'h0000000000000001; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -56907,12 +173467,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2436939\n"); + $fwrite(fp,"2265659\n"); end - x = 64'h3D3647E2D0587670; - y = 64'hBEC000000007DFFF; - z = 64'h206FFFFFFFF7FBFF; - ans = 64'hBC0647E2D0636DD0; + x = 64'hB86F21204321D590; + y = 64'hAF3FFFFFFBFFE000; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -56954,10 +173514,3770 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2438953\n"); + $fwrite(fp,"2266273\n"); end - x = 64'h434FFFFFFFFFFFFE; + x = 64'h4340000000000000; + y = 64'h7FF0000000000001; + z = 64'hBF8FFFBFFFFFFEFE; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2266887\n"); + end + x = 64'h6D50100000007FFF; + y = 64'h41FC0000001FFFFF; + z = 64'hC1FF398F11A754F1; + ans = 64'h6F5C1C000020FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2267501\n"); + end + x = 64'hFFEA6D705F94B444; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2268115\n"); + end + x = 64'h4340000000000000; + y = 64'h41D0003FFFFF0000; + z = 64'h3AA3FFFFFFEFFFFF; + ans = 64'h4520003FFFFF0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2268729\n"); + end + x = 64'h43FCE6E55903E977; + y = 64'h8000000000000000; + z = 64'hBC4FFDFFFFFFF7FF; + ans = 64'hBC4FFDFFFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2269343\n"); + end + x = 64'h4340000000000000; + y = 64'h37EB5BDAF53EB4EB; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2269957\n"); + end + x = 64'h3F7FFFFFFFFEF000; + y = 64'h3FDFFFFFF8000100; + z = 64'hBED000FFFFFFFBFF; + ans = 64'h3F6FF7FF77FEF102; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2270571\n"); + end + x = 64'h4340000000000000; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2271185\n"); + end + x = 64'h77CFFFE00000000F; + y = 64'h3F1FFFF80FFFFFFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'h76FFFFD81007F00E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2271799\n"); + end + x = 64'h4340000000000000; + y = 64'h8010000000000000; + z = 64'hC3707FFFFFFFFDFF; + ans = 64'hC3707FFFFFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2272413\n"); + end + x = 64'h002FFFDFFFFFFFDE; + y = 64'h3E8FF00000000100; + z = 64'h40811626F5BEB56D; + ans = 64'h40811626F5BEB56D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2273027\n"); + end + x = 64'hC7EC000000000010; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h081C00000000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2273641\n"); + end + x = 64'h4340000000000000; + y = 64'h4010000000000201; + z = 64'h801000000200FFFE; + ans = 64'h4360000000000201; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2274255\n"); + end + x = 64'h41B0000000000DFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h40202FFFAD16AF0E; + ans = 64'h40202FFFAD16AF0E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2274869\n"); + end + x = 64'h4340000000000000; + y = 64'hC36D72FC4F782B37; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'hC6BD72FC4F782B37; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2275483\n"); + end + x = 64'hDB8FFFFFFE00007E; + y = 64'h9FC000003FDFFFFF; + z = 64'h4034F071C6234836; + ans = 64'h4034F071C6234836; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2276097\n"); + end + x = 64'h4340000000000000; + y = 64'hBCA0000000000001; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2276711\n"); + end + x = 64'h47F00023FFFFFFFF; + y = 64'h359F000020000000; + z = 64'hBFF0000000000000; + ans = 64'hBFEFFFFFFFFF07FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2277325\n"); + end + x = 64'h4340000000000000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h64BFFFFFFDFF7FFE; + ans = 64'h64BFFFFFFDFF7FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2277939\n"); + end + x = 64'h43DFFFFFFF007FFE; + y = 64'h400FFBFFFFFFBFFF; + z = 64'h3FFF8000FFFFFFFF; + ans = 64'h43FFFBFFFF005FED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2278553\n"); + end + x = 64'hBF30000000200400; + y = 64'hBFD0000000000001; + z = 64'h0010000000000000; + ans = 64'h3F10000000200401; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2279167\n"); + end + x = 64'h4340000000000000; + y = 64'h3FFB2B4407EDF5B5; + z = 64'hBFD000000001FEFE; + ans = 64'h434B2B4407EDF5B5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2279781\n"); + end + x = 64'hC641F08986F4CAEF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h4037FDFFFFFFFFFE; + ans = 64'h4631F08986F4CAEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2280395\n"); + end + x = 64'h4340000000000000; + y = 64'hBFF6A9ACDE055875; + z = 64'h4340000000000000; + ans = 64'hC32AA6B3781561D4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2281009\n"); + end + x = 64'hC077209428630E48; + y = 64'h3F9BFFFFFFFFFEFF; + z = 64'h7DEFFFFFFEFFF800; + ans = 64'h7DEFFFFFFEFFF800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2281623\n"); + end + x = 64'h4340000000000000; + y = 64'hBFE0000000000000; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2282237\n"); + end + x = 64'hB7EC000000007FFE; + y = 64'h802DFFF7FFFFFFFF; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2282851\n"); + end + x = 64'h4340000000000000; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBFD1311DCA7752FE; + ans = 64'hC33FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2283465\n"); + end + x = 64'h7FFC036815DA618A; + y = 64'h3FA2B0315180BE7A; + z = 64'h001A394446183D85; + ans = 64'h7FFC036815DA618A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2284079\n"); + end + x = 64'h47FFFFFFFFFFFFFF; + y = 64'hBFF0000000000000; + z = 64'h0000000000000001; + ans = 64'hC7FFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2284693\n"); + end + x = 64'h4340000000000000; + y = 64'hB25FFFDFFFBFFFFF; + z = 64'hA20F7F3E8492CDF4; + ans = 64'hB5AFFFDFFFBFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2285307\n"); + end + x = 64'hC00D57DC0A031EEA; + y = 64'hBFF0000000000001; + z = 64'h4440000040000200; + ans = 64'h4440000040000200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2285921\n"); + end + x = 64'h4340000000000000; + y = 64'hC7F0000BFFFFFFFF; + z = 64'h4010000000000001; + ans = 64'hCB40000BFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2286535\n"); + end + x = 64'hCD6FFBBFFFFFFFFF; + y = 64'h434FFFFFFF7FFBFF; + z = 64'h0020949B37C68B32; + ans = 64'hD0CFFBBFFF800CFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2287149\n"); + end + x = 64'h4340000000000000; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hC340000000000001; + ans = 64'hC358000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2287763\n"); + end + x = 64'hBFF07FFFFFFEFFFF; + y = 64'hC34FFFFFFFFFEF7F; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h43507FFFFFFEF77C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2288377\n"); + end + x = 64'h4340000000000000; + y = 64'hC000000000000001; + z = 64'hC92C1CF2ED58314F; + ans = 64'hC92C1CF2ED58314F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2288991\n"); + end + x = 64'h41CCAE6C2A82DBEE; + y = 64'h3CA00001F7FFFFFF; + z = 64'h40A8D91B4EE4EC1F; + ans = 64'h40A8D91B4EE881ED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2289605\n"); + end + x = 64'h434FF000000003FE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2290219\n"); + end + x = 64'h4340000000000000; + y = 64'hC002CB498F049251; + z = 64'h70DFFFFF00003FFE; + ans = 64'h70DFFFFF00003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2290833\n"); + end + x = 64'hC03FFFFFFFC00001; + y = 64'hC010000000000000; + z = 64'h7FFFC00000000100; + ans = 64'h7FFFC00000000100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2291447\n"); + end + x = 64'h4340000000000000; + y = 64'hC3EEA4A69C2CA85E; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'hC73EA4A69C2CA85E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2292061\n"); + end + x = 64'hC3FFFFFFFB7FFFFF; + y = 64'hCEFDFFFFBFFFFFFF; + z = 64'h3CCFFFFFFFC0007F; + ans = 64'h530DFFFFBBC80007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2292675\n"); + end + x = 64'h4340000000000000; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC370000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2293289\n"); + end + x = 64'hC090010000007FFE; + y = 64'h8007AEAE57E64007; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2293903\n"); + end + x = 64'h4340000000000000; + y = 64'hC340000000000000; + z = 64'hD690000003FFFFF7; + ans = 64'hD690000003FFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2294517\n"); + end + x = 64'hB80FFFEFFFFFFFEF; + y = 64'hC3DFFFFFF7FFFFFE; + z = 64'h47E887DAC10630D3; + ans = 64'h47E887DAC10630D3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2295131\n"); + end + x = 64'hDFAFEFFBFFFFFFFE; + y = 64'hC340000000000001; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2295745\n"); + end + x = 64'h4340000000000000; + y = 64'h388FFFFF8000001F; + z = 64'hC008001FFFFFFFFE; + ans = 64'hC008001FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2296359\n"); + end + x = 64'hC01FFFFFFFBFFDFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3F6FFFFFFFF0FFFF; + ans = 64'h437FFFFFFFBFFDFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2296973\n"); + end + x = 64'h4340000000000000; + y = 64'hBFDF5FFFFFFFFFFE; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'hC32F5FFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2297587\n"); + end + x = 64'hC03EFFFFFFFEFFFF; + y = 64'h401FFFFBC0000000; + z = 64'hC011FFFFFDFFFFFF; + ans = 64'hC06F8FFBE1EEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2298201\n"); + end + x = 64'h4340000000000000; + y = 64'hFFE0000000000001; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2298815\n"); + end + x = 64'hA71F000000000002; + y = 64'h43E0000007F00000; + z = 64'hBCA0000000000000; + ans = 64'hBCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2299429\n"); + end + x = 64'h4340000000000000; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hC1CFF7FFFFFFFDFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2300043\n"); + end + x = 64'h43C0001000000200; + y = 64'h7FF00010007FFFFE; + z = 64'hC02FFE000001FFFF; + ans = 64'h7FF80010007FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2300657\n"); + end + x = 64'h41E0000800000040; + y = 64'hFFF0000000000000; + z = 64'hFFE0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2301271\n"); + end + x = 64'h4340000000000000; + y = 64'hBFDF7FFFFF7FFFFF; + z = 64'h43DFFFFFFE000003; + ans = 64'h43DFFC0FFE001003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2301885\n"); + end + x = 64'hBFB42B92E0CE8966; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h401FFFC000000400; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2302499\n"); + end + x = 64'h4340000000000000; + y = 64'hC3E000007FFFFFFE; + z = 64'h3FF0000000000000; + ans = 64'hC73000007FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2303113\n"); + end + x = 64'h43DBFFFFFFFF0000; + y = 64'h37FB3FA406ED06DD; + z = 64'hBF4000007FFFC000; + ans = 64'hBF4000007FFFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2303727\n"); + end + x = 64'h4340000000000001; y = 64'h0000000000000000; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2304341\n"); + end + x = 64'hBF3000000001FFEE; + y = 64'h7FDFFFFFE001FFFF; + z = 64'h8010000000000001; + ans = 64'hFF1FFFFFE005FFDB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2304955\n"); + end + x = 64'h4340000000000001; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC00000000001EFFF; + ans = 64'hC00000000001EFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2305569\n"); + end + x = 64'h41E00000F0000000; + y = 64'hC1FFFFFF801FFFFF; + z = 64'h3A0C007FFFFFFFFF; + ans = 64'hC3F00000B00FFC40; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2306183\n"); + end + x = 64'h434AA2D8FC9A46F1; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2306797\n"); + end + x = 64'h4340000000000001; + y = 64'h5290000FFFFFFF80; + z = 64'hC0253D605ADC6994; + ans = 64'h55E0000FFFFFFF81; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2307411\n"); + end + x = 64'h40300000047FFFFF; + y = 64'h0010000000000001; + z = 64'h40028347123FC721; + ans = 64'h40028347123FC721; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2308025\n"); + end + x = 64'h4340000000000001; + y = 64'h402FFDFFFFFFFFFA; + z = 64'h3FE0000000000001; + ans = 64'h437FFDFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2308639\n"); + end + x = 64'hBFFFFFFFFFF7F7FE; + y = 64'h4003FB7F21F644D6; + z = 64'hB81FFFFFF7FFFF80; + ans = 64'hC013FB7F21F140F6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2309253\n"); + end + x = 64'h4340000000000001; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2309867\n"); + end + x = 64'hC3CFFFFF80010000; + y = 64'h282FFFFFFFFFC000; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'hAC0FFFFF8000C000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2310481\n"); + end + x = 64'h4340000000000001; + y = 64'h3CA0000000000001; + z = 64'h41D15D35F884E088; + ans = 64'h41D15D35F8C4E088; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2311095\n"); + end + x = 64'h401FDFFFFFFFFFFC; + y = 64'h43F8C520AF7D5809; + z = 64'h001FFFFFFFFFE7FF; + ans = 64'h4428AC5B8ECDDAAE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2311709\n"); + end + x = 64'h37E0000001FBFFFF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2312323\n"); + end + x = 64'h4340000000000001; + y = 64'h404A43217BCC7B0C; + z = 64'h3E8000080003FFFF; + ans = 64'h439A43217BCC7B0E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2312937\n"); + end + x = 64'h60F00000200001FF; + y = 64'h3FD0000000000000; + z = 64'hBFDEFFFFFFFFEFFF; + ans = 64'h60D00000200001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2313551\n"); + end + x = 64'h4340000000000001; + y = 64'h7FFFFFFFFFFFFC06; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFC06; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2314165\n"); + end + x = 64'hC0225253367BEB29; + y = 64'hBFFFFC00000FFFFE; + z = 64'h3F0FFDFFFFC00000; + ans = 64'h4032500CEBDE44CC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2314779\n"); + end + x = 64'h4340000000000001; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'h432FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2315393\n"); + end + x = 64'h434000000003FFFF; + y = 64'h43479024D7FF09EF; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -57001,12 +177321,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2440967\n"); + $fwrite(fp,"2316007\n"); end - x = 64'hB62FFFFE00400000; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hB7300003FFFFFFFF; - ans = 64'hB7300003FFFFFFFF; + x = 64'h4340000000000001; + y = 64'h3FE0000000000000; + z = 64'h33DFFE000FFFFFFF; + ans = 64'h4330000000000001; rn = 1; rz = 0; rm = 0; @@ -57048,12 +177368,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2442981\n"); + $fwrite(fp,"2316621\n"); end - x = 64'h4482000FFFFFFFFF; - y = 64'h495FFFFFFEFFFFFF; - z = 64'hBFE917F807D49DAF; - ans = 64'h4DF2000FFF6FFF7E; + x = 64'h37E0000000000000; + y = 64'h79D7A559DDB1F430; + z = 64'h3E70001000001FFF; + ans = 64'h71C7A559DDB1F430; rn = 1; rz = 0; rm = 0; @@ -57095,12 +177415,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2444995\n"); + $fwrite(fp,"2317235\n"); end - x = 64'h434FFFFFFFFFFFFE; - y = 64'h3CA0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; + x = 64'hC7FF80000FFFFFFF; + y = 64'h3FE0000000000001; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC7EF800010000001; rn = 1; rz = 0; rm = 0; @@ -57142,12 +177462,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2447009\n"); + $fwrite(fp,"2317849\n"); end - x = 64'hC06321EC0ECEF83A; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h43DFFFFFFFEFFF7F; - ans = 64'h43DFFFFFFFEFFF7F; + x = 64'h4340000000000001; + y = 64'hBCAB7CDC15514299; + z = 64'hC3F000001FFFF7FF; + ans = 64'hC3F000001FFFF7FF; rn = 1; rz = 0; rm = 0; @@ -57189,12 +177509,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2449023\n"); + $fwrite(fp,"2318463\n"); end - x = 64'hEE9FFDFFFFF7FFFF; - y = 64'hC6C000000000F800; - z = 64'hC386807C8536E615; - ans = 64'h756FFDFFFFF9EFE0; + x = 64'hB05001FFFFF00000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hFFFFFFEFFFFFBFFE; + ans = 64'hFFFFFFEFFFFFBFFE; rn = 1; rz = 0; rm = 0; @@ -57236,12 +177556,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2451037\n"); + $fwrite(fp,"2319077\n"); end - x = 64'h434FFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'h433FFFFFFFFFFFFB; + x = 64'h4340000000000001; + y = 64'h410D90149AC990FB; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h445D90149AC990FD; rn = 1; rz = 0; rm = 0; @@ -57283,12 +177603,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2453051\n"); + $fwrite(fp,"2319691\n"); end - x = 64'hC7F7BED1D818FB7C; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hBFF0000000900000; - ans = 64'hC7F7BED1D818FB7B; + x = 64'h41CFE003FFFFFFFF; + y = 64'h402DFFFFFFFFFFFE; + z = 64'h52076C977151EFF0; + ans = 64'h52076C977151EFF0; rn = 1; rz = 0; rm = 0; @@ -57330,12 +177650,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2455065\n"); + $fwrite(fp,"2320305\n"); end - x = 64'h6FBFFFFFFFFFFCFF; - y = 64'hC020000008000100; - z = 64'hAC62001000000000; - ans = 64'hEFF0000007FFFF7F; + x = 64'h4340000000000001; + y = 64'h3FF0000000000001; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h4340000000000002; rn = 1; rz = 0; rm = 0; @@ -57377,12 +177697,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2457079\n"); + $fwrite(fp,"2320919\n"); end - x = 64'h434FFFFFFFFFFFFE; + x = 64'hC80FEFFFFFFFDFFE; + y = 64'hC8001FDFFFFFFFFF; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2321533\n"); + end + x = 64'h4340000000000001; y = 64'h3FFFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4363FFFFFFFFFFFE; + z = 64'h42900000010000FF; + ans = 64'h4350010000001000; rn = 1; rz = 0; rm = 0; @@ -57424,12 +177791,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2459093\n"); + $fwrite(fp,"2322147\n"); end - x = 64'h0C1A68326C1E35DC; - y = 64'h4000000000000001; - z = 64'h7FE00000FFFFFFF0; - ans = 64'h7FE00000FFFFFFF0; + x = 64'hC3D000800007FFFE; + y = 64'hBEBFFFFFFFFFF5FF; + z = 64'hC01FFFFF7FF00000; + ans = 64'h42A000800007EAFD; rn = 1; rz = 0; rm = 0; @@ -57471,12 +177838,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2461107\n"); + $fwrite(fp,"2322761\n"); end - x = 64'hC3FAF80EB5114084; - y = 64'h0003D852E11515F0; - z = 64'h3D9FFFEFFFFFE000; - ans = 64'h3D9FFFEFFFFFE000; + x = 64'h41EF6DB877E81671; + y = 64'h4000000000000000; + z = 64'hC000000000000000; + ans = 64'h41FF6DB877C81671; rn = 1; rz = 0; rm = 0; @@ -57518,10 +177885,1373 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2463121\n"); + $fwrite(fp,"2323375\n"); end - x = 64'h434FFFFFFFFFFFFE; + x = 64'h4340000000000001; + y = 64'h7FD0080007FFFFFE; + z = 64'hC4B001FFFFFFFE00; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2323989\n"); + end + x = 64'h407000400003FFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hFFF0000100003FFF; + ans = 64'hFFF8000100003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2324603\n"); + end + x = 64'h4340000000000001; + y = 64'hFFF003FFFFFFFF7E; + z = 64'h3CA0000000000000; + ans = 64'hFFF803FFFFFFFF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2325217\n"); + end + x = 64'hBFE000000000013F; + y = 64'h47AFFE001FFFFFFF; + z = 64'h4005F18C2B986B5B; + ans = 64'hC79FFE002000027D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2325831\n"); + end + x = 64'h4340000000000001; + y = 64'h4010000000000000; + z = 64'hBFD0000000000000; + ans = 64'h4360000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2326445\n"); + end + x = 64'hC34FEFFFFFFFFFEE; + y = 64'hC02001FFFFFFFEFE; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2327059\n"); + end + x = 64'h4340000000000001; y = 64'h401FFFFFFFFFFFFF; + z = 64'h3F9040FFFFFFFFFF; + ans = 64'h4370000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2327673\n"); + end + x = 64'h37EFFFFDFFEFFFFE; + y = 64'hBFB00000027FFFFE; + z = 64'hC34002000000003F; + ans = 64'hC34002000000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2328287\n"); + end + x = 64'h403873F06862F88A; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'h406853F06862F888; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2328901\n"); + end + x = 64'h4340000000000001; + y = 64'hC3DFFFFFFFFFF700; + z = 64'h47F297807F5E74B8; + ans = 64'h47F296807F5E74B8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2329515\n"); + end + x = 64'hC3FFFFFE00FFFFFF; + y = 64'h4340000000000001; + z = 64'h41C6C1CE73976263; + ans = 64'hC74FFFFE01000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2330129\n"); + end + x = 64'h4340000000000001; + y = 64'h400DAAF23F993605; + z = 64'h0010000000000001; + ans = 64'h435DAAF23F993607; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2330743\n"); + end + x = 64'hAFFFFFFFFFF7FF00; + y = 64'h002FFFFF80000200; + z = 64'h3F0E34BFD440A8BC; + ans = 64'h3F0E34BFD440A8BC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2331357\n"); + end + x = 64'h4340000000000001; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hBCA0000000000001; + ans = 64'h46A0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2331971\n"); + end + x = 64'hCAEFFFFFFFFF0FFF; + y = 64'h3F0FFFFFFFCFFFFE; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'hCA0FFFFFFFCF0FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2332585\n"); + end + x = 64'h4340000000000001; + y = 64'h7FE0000000000001; + z = 64'hA5B07DFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2333199\n"); + end + x = 64'h41F0000100003FFF; + y = 64'h3CAFFFFFFFE001FE; + z = 64'hC02FFFF8000000FF; + ans = 64'hC02FFFF7DFFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2333813\n"); + end + x = 64'h7FF0011FFFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'h7FF8011FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2334427\n"); + end + x = 64'h4340000000000001; + y = 64'hC010010000000000; + z = 64'h4033FFFFFFFFFFFE; + ans = 64'hC36000FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2335041\n"); + end + x = 64'hB2D5935872999FF4; + y = 64'h7FF0000000000000; + z = 64'h401000000081FFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2335655\n"); + end + x = 64'h4340000000000001; + y = 64'hC06066C8FFE71609; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hC3B066C8FFE7160A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2336269\n"); + end + x = 64'h3FD0004000000000; + y = 64'h38A0000000030000; + z = 64'hADF07FFFFC000000; + ans = 64'h388000400003000C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2336883\n"); + end + x = 64'h4340000000000001; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2337497\n"); + end + x = 64'h14C000004007FFFF; + y = 64'h37FFFFFFFF87FFFF; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2338111\n"); + end + x = 64'h4340000000000001; + y = 64'h8000000000000000; + z = 64'h43D72945D1D10C0A; + ans = 64'h43D72945D1D10C0A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2338725\n"); + end + x = 64'h6CEFFFFDFFFFFBFF; + y = 64'hCF45787D5C8AEF60; + z = 64'h39C0003FFFDFFFFF; + ans = 64'hFC45787C050316E8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2339339\n"); + end + x = 64'hB925E77B943E3684; + y = 64'h8000000000000001; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2339953\n"); + end + x = 64'h4340000000000001; + y = 64'hBC2003FFFFFFFFFE; + z = 64'h381FFFFFFFD00000; + ans = 64'hBF7003FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2340567\n"); + end + x = 64'h3FFFFBFEFFFFFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h4034A12AB8ACFA1E; + ans = 64'h4034A12AB8ACFA1E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2341181\n"); + end + x = 64'h4340000000000001; + y = 64'h3FE07FFFFFFFFFF0; z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; @@ -57565,12 +179295,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2465135\n"); + $fwrite(fp,"2341795\n"); end - x = 64'h3FF998BCFCA42C40; - y = 64'h4340000000000001; - z = 64'h47E487C0C983E604; - ans = 64'h47E487C0C983E604; + x = 64'h434890F6EC8A3B10; + y = 64'h401FFFFFFFF0000F; + z = 64'hC7FFEFFFFFFFFFFC; + ans = 64'hC7FFEFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -57612,7 +179342,9877 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2467149\n"); + $fwrite(fp,"2342409\n"); + end + x = 64'h4340000000000001; + y = 64'h8010000000000001; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h8360000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2343023\n"); + end + x = 64'hC0F0000000200003; + y = 64'hC3CFFC0000007FFF; + z = 64'h4010000000000000; + ans = 64'h44CFFC0000407805; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2343637\n"); + end + x = 64'h4340000000000001; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h334F7FFBFFFFFFFE; + ans = 64'h334F7FFBFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2344251\n"); + end + x = 64'hC3C00000003FFFFF; + y = 64'h38C0000000FFFBFF; + z = 64'hB80624BD323C64F9; + ans = 64'hBC900000013FFBFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2344865\n"); + end + x = 64'hC1F00000000000FB; + y = 64'hBCA0000000000000; + z = 64'hBFD0000000000000; + ans = 64'hBFCFFFFC00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2345479\n"); + end + x = 64'h4340000000000001; + y = 64'h3FFBFFFFFFFFFFEF; + z = 64'hC01FF800000003FF; + ans = 64'h434BFFFFFFFFFFED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2346093\n"); + end + x = 64'h41EAD27A45E8198B; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h9660000001FFFFEE; + ans = 64'hBEAAD27A45E8198A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2346707\n"); + end + x = 64'h4340000000000001; + y = 64'h17CFDFFFFFFFFFFC; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2347321\n"); + end + x = 64'h800FFFFFF7FDFFFF; + y = 64'h3E2FFF7BFFFFFFFF; + z = 64'h4AC1FFEFFFFFFFFF; + ans = 64'h4AC1FFEFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2347935\n"); + end + x = 64'h4340000000000001; + y = 64'hBFD0000000000000; + z = 64'h8000000000000000; + ans = 64'hC320000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2348549\n"); + end + x = 64'hCF5FFFFFFFEFE000; + y = 64'hC023FFFFFFE00000; + z = 64'h4000000000000001; + ans = 64'h4F93FFFFFFD5EC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2349163\n"); + end + x = 64'h4340000000000001; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC7FFFFE1FFFFFFFF; + ans = 64'hC7FFFFE1FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2349777\n"); + end + x = 64'hC51FFC00000FFFFF; + y = 64'hC1D7FFFFFFFFF7FE; + z = 64'hB8C0500000000000; + ans = 64'h4707FD00000BF7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2350391\n"); + end + x = 64'h3FED5F03FF053628; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBCA0000000000001; + ans = 64'hBFDD5F03FF053628; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2351005\n"); + end + x = 64'h4340000000000001; + y = 64'h37ECFFFFFFFFFFFE; + z = 64'h3CFFDFFFFFFFFFFE; + ans = 64'h3CFFE00001CFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2351619\n"); + end + x = 64'h445FFFFFF8000007; + y = 64'hBFE0000000000001; + z = 64'h41F528D1252D9058; + ans = 64'hC44FFFFFF7FF56C2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2352233\n"); + end + x = 64'h4340000000000001; + y = 64'h41FE7CFA871C6E01; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2352847\n"); + end + x = 64'hFFD00FFFFFFFFFFC; + y = 64'h401FFEF000000000; + z = 64'hC69FFFFFFFF001FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2353461\n"); + end + x = 64'h4340000000000001; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2354075\n"); + end + x = 64'h3FF0400001FFFFFF; + y = 64'hBFB00000010000FF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFEFBFFFFCFBFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2354689\n"); + end + x = 64'h4340000000000001; + y = 64'hBFF0000000000001; + z = 64'hBFE0000010FFFFFF; + ans = 64'hC340000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2355303\n"); + end + x = 64'hC3409FFFFFFFFFFE; + y = 64'hFFFFFFF7FFFFFFBE; + z = 64'h41D71184951FDAC6; + ans = 64'hFFFFFFF7FFFFFFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2355917\n"); + end + x = 64'hBFE000003BFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h3FF000003BFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2356531\n"); + end + x = 64'h4340000000000001; + y = 64'h30D07FFF80000000; + z = 64'hC34FFFF00001FFFE; + ans = 64'hC34FFFF00001FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2357145\n"); + end + x = 64'h3FC000002000000F; + y = 64'hC000000000000000; + z = 64'h43D00000001F7FFF; + ans = 64'h43D00000001F7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2357759\n"); + end + x = 64'h4340000000000001; + y = 64'h3FDFFF0000001000; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC348003FFFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2358373\n"); + end + x = 64'h48001FFFFFFFFFFC; + y = 64'h3F32E0A31D93728A; + z = 64'hBFFFFFFFFF003FFF; + ans = 64'h4743066463CE996A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2358987\n"); + end + x = 64'h4340000000000001; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2359601\n"); + end + x = 64'hCDFFFFFFF00000FE; + y = 64'h5ECF800007FFFFFE; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'hECDF7FFFF84000F4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2360215\n"); + end + x = 64'h4340000000000001; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h7FE00003FFFFC000; + ans = 64'h7FE00003FFFFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2360829\n"); + end + x = 64'h34C20BA1CFD35142; + y = 64'h40102003FFFFFFFF; + z = 64'h47E03FFFFFFFFFFF; + ans = 64'h47E03FFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2361443\n"); + end + x = 64'h3FBF19DC6F82A36E; + y = 64'hC010000000000001; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hBFDF19DC6F82A370; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2362057\n"); + end + x = 64'h4340000000000001; + y = 64'h8D6A9D993D1D2C6E; + z = 64'hB9A3089D3E427A9F; + ans = 64'hB9A3089D3E427A9F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2362671\n"); + end + x = 64'hC3D0000100000001; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h44CFFF8040000000; + ans = 64'h44D0004020080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2363285\n"); + end + x = 64'h4340000000000001; + y = 64'h7FD8140C75BE2D61; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2363899\n"); + end + x = 64'hFFFFE00000002000; + y = 64'h41F813AD63F0CC13; + z = 64'h802FFFFFFFF7FFC0; + ans = 64'hFFFFE00000002000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2364513\n"); + end + x = 64'h4340000000000001; + y = 64'hC340000000000001; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'hC690000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2365127\n"); + end + x = 64'hBCB58BA32DF145E0; + y = 64'h3FBE0000003FFFFF; + z = 64'h3FE0000000000000; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2365741\n"); + end + x = 64'h4340000000000001; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hBDD3EF62FAA25F5B; + ans = 64'hC6A0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2366355\n"); + end + x = 64'hC7EFFFFFFFFEFFDE; + y = 64'hBFC10003FFFFFFFE; + z = 64'hFFDFFFFFFFFFF000; + ans = 64'hFFDFFFFFFFFFF000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2366969\n"); + end + x = 64'hDF2FFFFF800000FE; + y = 64'hFFE0000000000000; + z = 64'h8000000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2367583\n"); + end + x = 64'h4340000000000001; + y = 64'hBE8ADC8A28E4158C; + z = 64'h3FFFFFFFFFFEEFFF; + ans = 64'hC1DADC8A2864158E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2368197\n"); + end + x = 64'hCF4FE0FFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h38CD934899ED1CBD; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2368811\n"); + end + x = 64'h4340000000000001; + y = 64'hFFEFFF800001FFFF; + z = 64'hC010000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2369425\n"); + end + x = 64'h402FFC00000000FF; + y = 64'h3CAFFFFFFEFFFFF6; + z = 64'hC3F0000803FFFFFF; + ans = 64'hC3F0000803FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2370039\n"); + end + x = 64'h4340000000000001; + y = 64'hFFF0000000000000; + z = 64'h4340000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2370653\n"); + end + x = 64'hC3DFFFFFFBDFFFFF; + y = 64'hFFF0000040080000; + z = 64'h3FD0000000000001; + ans = 64'hFFF8000040080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2371267\n"); + end + x = 64'h4340000000000001; + y = 64'hFFF0000000000001; + z = 64'h7D5FFDFF7FFFFFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2371881\n"); + end + x = 64'h4000007FFFFFFF7E; + y = 64'h3FDCACB54358D66E; + z = 64'hFFD07FFFFFFFFFFA; + ans = 64'hFFD07FFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2372495\n"); + end + x = 64'hBFE1329CAFA09F26; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h7FF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2373109\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBF97E2B472C87667; + z = 64'hBFDDFC0000000000; + ans = 64'hC2F7E2B472C8766E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2373723\n"); + end + x = 64'hC3CB5CC56722BF2E; + y = 64'h0000000000000001; + z = 64'h4347A6A653DCE7C6; + ans = 64'h4347A6A653DCE7C6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2374337\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h80200000000001DF; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2374951\n"); + end + x = 64'hC0B000000E000000; + y = 64'hC7EFF7BFFFFFFFFF; + z = 64'hBBA001FFFFFFFEFF; + ans = 64'h48AFF7C01BF8C7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2375565\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2376179\n"); + end + x = 64'h47FBAFD5DD1373A4; + y = 64'h41C00000000003FB; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h49CBAFD5DD137A87; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2376793\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h0010000000000000; + z = 64'hB7EA274BBE534719; + ans = 64'hB7EA274BBE534719; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2377407\n"); + end + x = 64'h3F7FFFFFFFF80FFF; + y = 64'hB7E0000000400020; + z = 64'h43E0000200000000; + ans = 64'h43E0000200000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2378021\n"); + end + x = 64'hC3EBFFFFFFFFFFFB; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2378635\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h402FFF7FFFF00000; + z = 64'hFFDDFFFFFF7FFFFE; + ans = 64'hFFDDFFFFFF7FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2379249\n"); + end + x = 64'hC7ED8AB087F5C05B; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h3FB7FFFFFFFF7FFF; + ans = 64'h3FB7FFFFFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2379863\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h3F00080002000000; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h4260080001FFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2380477\n"); + end + x = 64'h402020000001FFFF; + y = 64'hBFDFFFFFFFBBFFFF; + z = 64'hC03F214815D6A0C8; + ans = 64'hC04194A40AE747E4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2381091\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2381705\n"); + end + x = 64'h47FD9D82C52C1E71; + y = 64'h801FFFFFFFC0001F; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h882D9D82C4F0E388; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2382319\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h802DCFE0F56C6C8F; + ans = 64'h400FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2382933\n"); + end + x = 64'hC3C000000000203F; + y = 64'h41CFFFFFEFFFFDFF; + z = 64'h179FFFFFFFFFBF7F; + ans = 64'hC59FFFFFF0003E7D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2383547\n"); + end + x = 64'h401FFFFFFFFE1FFF; + y = 64'h3FD0000000000001; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2384161\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h3FBFFFFFFFFFFFC3; + z = 64'hC04DFFFE00000000; + ans = 64'h431FFFFFFFFFFED2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2384775\n"); + end + x = 64'h47DFFFFF7DFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h47FFF00001FFFFFE; + ans = 64'h4801F7FFF8DFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2385389\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h44FFFFFFEFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h485FFFFFEFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2386003\n"); + end + x = 64'hBF9FFFFFBFFFFFBF; + y = 64'h406FFFFFFFC01FFF; + z = 64'h3FFFFDFFFFFFFF00; + ans = 64'hC018007FBFC01FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2386617\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h3FE0000000000001; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2387231\n"); + end + x = 64'h4370003FFFFFFEFE; + y = 64'h41C4C250A2F4F548; + z = 64'h0010000000000000; + ans = 64'h4544C2A3AC377FCD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2387845\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h411FDFDFFFFFFFFF; + ans = 64'h435000000001FDFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2388459\n"); + end + x = 64'hC065E9EF4F9D3E21; + y = 64'hFFDE0F6202282F1D; + z = 64'hC0906DD67E9476DC; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2389073\n"); + end + x = 64'hBFED82E3C6C037DB; + y = 64'h3FF0000000000000; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2389687\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hC020004000003FFF; + z = 64'hBA8FFF80000003FF; + ans = 64'hC380004000003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2390301\n"); + end + x = 64'h3FFC000000000800; + y = 64'h3FF0000000000001; + z = 64'h43EFFC0000003FFF; + ans = 64'h43EFFC0000003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2390915\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h40200000200000FE; + z = 64'hBFE0000000000000; + ans = 64'h43800000200000FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2391529\n"); + end + x = 64'h401FFFFFFDEFFFFF; + y = 64'hBEBFFFFFFDFDFFFF; + z = 64'hBFBFFFFFFFC0007F; + ans = 64'hBFC0007FFFDFEFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2392143\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h4000000000000000; + z = 64'h3FF0000000000000; + ans = 64'h435FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2392757\n"); + end + x = 64'hC3DFFFFFFD7FFFFE; + y = 64'hC1C7D668CDFFE997; + z = 64'h0000000000000001; + ans = 64'h45B7D668CC232965; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2393371\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h4000000000000001; + z = 64'h9010FFFFFFFEFFFF; + ans = 64'h4360000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2393985\n"); + end + x = 64'h000FFC1FFFFFFFFF; + y = 64'h3FBFFFFFF0001FFF; + z = 64'h01A54E0A36E764E7; + ans = 64'h01A54E0A37E726E7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2394599\n"); + end + x = 64'hB80FFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2395213\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBFF3FFF7FFFFFFFF; + z = 64'hC7FD05FDFF73E632; + ans = 64'hC7FD05FDFF73E632; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2395827\n"); + end + x = 64'h800FFFFFFFFFBFDE; + y = 64'h4010000000000000; + z = 64'h55B0AE982E8F89CC; + ans = 64'h55B0AE982E8F89CC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2396441\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h3FAF000100000000; + z = 64'hBFD0000000000001; + ans = 64'h430F0000FFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2397055\n"); + end + x = 64'hBFD001FFFFFFDFFF; + y = 64'hBE4FFFFFFE03FFFE; + z = 64'hFFE2BDEF6A61D7BE; + ans = 64'hFFE2BDEF6A61D7BE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2397669\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h3FE0000000000001; + ans = 64'h437FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2398283\n"); + end + x = 64'hFFFEEFB34C4329A7; + y = 64'h44AFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2398897\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h4340000000000000; + z = 64'hBEFF00000000007E; + ans = 64'h469FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2399511\n"); + end + x = 64'h002B563D959D14CC; + y = 64'h40F3396D3630BF96; + z = 64'h43DFFFFFFFFDFE00; + ans = 64'h43DFFFFFFFFDFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2400125\n"); + end + x = 64'h800FFFFFFFFBF7FE; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2400739\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hB814A433BE51486C; + z = 64'hF26000087FFFFFFF; + ans = 64'hF26000087FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2401353\n"); + end + x = 64'h40000000001003FF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hBFF00040000001FF; + ans = 64'h43600000001003FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2401967\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hC8000800007FFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hCB600800007FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2402581\n"); + end + x = 64'hB80393169FC8A232; + y = 64'hC0178CD9F52F1A10; + z = 64'h3E508001FFFFFFFF; + ans = 64'h3E508001FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2403195\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2403809\n"); + end + x = 64'hC3FF002000000000; + y = 64'hC012B1E30F60CDD3; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2404423\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hC06D84BF2BB77CB8; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2405037\n"); + end + x = 64'hC0200003FFFFBFFE; + y = 64'hC060007FFFFFBFFE; + z = 64'h37EFFFBFFFFFFFF6; + ans = 64'h40900084001F7FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2405651\n"); + end + x = 64'hBFCFE0000000000F; + y = 64'h7FF0000000000001; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2406265\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBFDFD933B5463C94; + z = 64'hC1F200000000003F; + ans = 64'hC33FD934D5463C93; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2406879\n"); + end + x = 64'h47FFFFFFFF800003; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h43DFFFFE0000FFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2407493\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBCA0001FF0000000; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hC000001FEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2408107\n"); + end + x = 64'h3F8FFFFFFDFFFEFE; + y = 64'hFFE004000000001F; + z = 64'hFFE003FFFFFFFFFB; + ans = 64'hFFE0440FFFFBFEF9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2408721\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h8000000000000001; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2409335\n"); + end + x = 64'hC1F000000000001F; + y = 64'hC00103FFFFFFFFFF; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2409949\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hCDC00200003FFFFE; + ans = 64'hCDC00200003FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2410563\n"); + end + x = 64'hC1CFFFF800001FFF; + y = 64'h7FEFFFFFFFF07FFF; + z = 64'h47E02DD4EE6F16D6; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2411177\n"); + end + x = 64'h3E53A6C3B8E56152; + y = 64'h8010000000000000; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2411791\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hC7EEFFFFFFFFFFBE; + z = 64'h3FF20000000FFFFF; + ans = 64'hCB4EFFFFFFFFFFBD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2412405\n"); + end + x = 64'h402FFFF80FFFFFFF; + y = 64'h8010000000000001; + z = 64'hC1437E9173E00C82; + ans = 64'hC1437E9173E00C82; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2413019\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hB810008000001FFE; + z = 64'h8010000000000000; + ans = 64'hBB70008000001FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2413633\n"); + end + x = 64'hC001FFE4B8134224; + y = 64'hBFD0000000037FFF; + z = 64'h7FE20000FFFFFFFF; + ans = 64'h7FE20000FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2414247\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBCA0000000000000; + z = 64'h3CA0000000000000; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2414861\n"); + end + x = 64'h3FEFFF7FFFFFFEFF; + y = 64'h8020002000000006; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2415475\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBCA0000000000001; + z = 64'hB57FFFFFFC00000E; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2416089\n"); + end + x = 64'hBFCFFFFFFFE003FE; + y = 64'hC190004004000000; + z = 64'h02502E98C105274C; + ans = 64'h4170004003F001BF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2416703\n"); + end + x = 64'h3FDFFFFFFFFF7000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h3FE0000000000001; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2417317\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h683905CF5187CAA5; + z = 64'hC030000800000007; + ans = 64'h6B9905CF5187CAA4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2417931\n"); + end + x = 64'hCC107FF000000000; + y = 64'hBFD0000000000000; + z = 64'h4507B3BFBB78EFE5; + ans = 64'h4BF07FF000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2418545\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hC07002000000003F; + z = 64'h8000000000000001; + ans = 64'hC3D002000000003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2419159\n"); + end + x = 64'h401000041FFFFFFE; + y = 64'hC34AB555D6DB3D20; + z = 64'hB71FF800000007FE; + ans = 64'hC36AB55CB99B5E81; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2419773\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h0010000000000001; + ans = 64'hC33FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2420387\n"); + end + x = 64'hC030007FFFFC0000; + y = 64'hBFDFFFFFE07FFFFE; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'h3F4FFC0EE07FE0FA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2421001\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBFE0000000000000; + z = 64'hC1DFC00000000002; + ans = 64'hC34000003F800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2421615\n"); + end + x = 64'h8000000002000000; + y = 64'hFF100001EFFFFFFF; + z = 64'h8D261BB2DA873976; + ans = 64'h3D800001EFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2422229\n"); + end + x = 64'hC3F0EC7428A39224; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h43F0EC7428A39223; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2422843\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFF82; + z = 64'h0011114A361594FC; + ans = 64'hC00FFFFFFFFFFF81; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2423457\n"); + end + x = 64'h3FD0FBBF78309F71; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h61EFF7FFFFFBFFFF; + ans = 64'h61EFF7FFFFFBFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2424071\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h3FF28976C15F0778; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2424685\n"); + end + x = 64'h480FFFFFFFFFFFFF; + y = 64'h3FF42A8ADCFAE94E; + z = 64'h418000005FFFFFFE; + ans = 64'h48142A8ADCFAE94D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2425299\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hC35FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2425913\n"); + end + x = 64'hC03502AC87DDF103; + y = 64'h3FA5997EC022603A; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC0138BA24EB04DDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2426527\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h3B2000010000007F; + ans = 64'hC35FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2427141\n"); + end + x = 64'h4026288FEF6695C2; + y = 64'hC032000000000200; + z = 64'hC1EF6A05D4EDE99D; + ans = 64'hC1EF6A05EDDB8B8A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2427755\n"); + end + x = 64'h4010007FFFFBFFFF; + y = 64'hC000000000000001; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'hC020007FFFFC0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2428369\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hC05FFF7FFFFFBFFE; + z = 64'hBFBFFF7FE0000000; + ans = 64'hC3BFFF7FFFFFBFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2428983\n"); + end + x = 64'h7FE61B8FDFDDBD73; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC7FFF807FFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2429597\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h4010000000088000; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2430211\n"); + end + x = 64'hC3D000077FFFFFFE; + y = 64'h4760000000103FFF; + z = 64'hC02FFFFFFFE00002; + ans = 64'hCB40000780104005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2430825\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hC010000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2431439\n"); + end + x = 64'h42D020001FFFFFFF; + y = 64'hCD1D000A016615E8; + z = 64'hC000000000000000; + ans = 64'hCFFD3A0A4F68F615; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2432053\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hBF7FFFFF7FC00000; + ans = 64'hC37FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2432667\n"); + end + x = 64'h480F4C07FE7541A5; + y = 64'h3FCFFFFFFF7FFFEE; + z = 64'h2DBFFFFBFFBFFFFF; + ans = 64'h47EF4C07FDF81173; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2433281\n"); + end + x = 64'hBFEFFFC00000003F; + y = 64'hC340000000000000; + z = 64'h3CA0000000000000; + ans = 64'h433FFFC00000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2433895\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hC3EFFDFFFFF80000; + z = 64'hAC9E00003FFFFFFF; + ans = 64'hC74FFDFFFFF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2434509\n"); + end + x = 64'hB1B00000001001FF; + y = 64'hC340000000000001; + z = 64'h3FDFFFFFFFEFFFFC; + ans = 64'h3FDFFFFFFFEFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2435123\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h48000000000000FA; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2435737\n"); + end + x = 64'hC1F0000000005FFF; + y = 64'hC3D000000007C000; + z = 64'h38180000000000FE; + ans = 64'h45D0000000081FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2436351\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2436965\n"); + end + x = 64'h44CFFF0001FFFFFE; + y = 64'h39E20528C2077414; + z = 64'hBFF0000000000001; + ans = 64'hBFEFFFFB7ED9D98A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2437579\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hFFE0000000000001; + z = 64'h400FFFFFFFFFF7EF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2438193\n"); + end + x = 64'hB9617FFFFFFFFFFF; + y = 64'hC0183814DE8DA0F4; + z = 64'h4650000000208000; + ans = 64'h4650000000208000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2438807\n"); + end + x = 64'h9870000401FFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h0010000000000001; + ans = 64'h5870000401FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2439421\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBFC00200001FFFFE; + z = 64'hC03000000043FFFE; + ans = 64'hC32002000020001D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2440035\n"); + end + x = 64'h2E4FFFFFFF8007FF; + y = 64'hFFF0000000000000; + z = 64'hC2A04000000FFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2440649\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBE21FC0000000000; + z = 64'h4340000000000001; + ans = 64'h433FFFFFFDC08002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2441263\n"); + end + x = 64'hC1D80000007FFFFF; + y = 64'hBFD00000400000FE; + z = 64'h215FEDFFFFFFFFFF; + ans = 64'h41B800006080017E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2441877\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hFFE0000000000001; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2442491\n"); + end + x = 64'h7FD20000001FFFFE; + y = 64'hFA7FFBFFDFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2443105\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h0000000000000000; + z = 64'hC3D1DD612FB617A3; + ans = 64'hC3D1DD612FB617A3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2443719\n"); + end + x = 64'hC3CFDFFFFFFEFFFF; + y = 64'hB7FFDFFFFFFBFFFE; + z = 64'h400FFF7FFFFEFFFE; + ans = 64'h400FFF7FFFFEFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2444333\n"); + end + x = 64'h37E0000100004000; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h000FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2444947\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h3FCFFFFFFFF0007E; + z = 64'hB1FFFFFFF0000003; + ans = 64'h432FFFFFFFF0007C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2445561\n"); + end + x = 64'h3FF36ED15DD5FF0B; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h40EFDEFFFFFFFFFE; + ans = 64'h40EFDEFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2446175\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h43D00001FFFFFFFE; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h47300001FFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2446789\n"); + end + x = 64'hC03FE0003FFFFFFF; + y = 64'hB7EFFFF7FFEFFFFF; + z = 64'hC000000FF7FFFFFE; + ans = 64'hC000000FF7FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2447403\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h0010000000000001; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2448017\n"); + end + x = 64'hC3C0FFFFFFFFDFFE; + y = 64'hA5900000080003FF; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2448631\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h400FFFFFEFFFFFF7; + ans = 64'h400FFFFFEFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2449245\n"); + end + x = 64'h0020000000110000; + y = 64'h6D2F133A7F2809C1; + z = 64'hC03000000001FFFC; + ans = 64'hC03000000001FFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2449859\n"); + end + x = 64'h3FB1518817833EC0; + y = 64'h3CA0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2450473\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC67FFFFFC0000800; + z = 64'h4034000000007FFE; + ans = 64'hC9DFFFFFC00007FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2451087\n"); + end + x = 64'h3FCFF00003FFFFFE; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h40396641E9D46149; + ans = 64'h40396641E9D46149; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2451701\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h7FF19D6663608B5D; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h7FF99D6663608B5D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2452315\n"); + end + x = 64'h7FDFFFFFFC07FFFF; + y = 64'h41CFFFFC01FFFFFE; + z = 64'hCA40001FFFF7FFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2452929\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h3FD0000000000000; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'h432FFFFFFFFFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2453543\n"); + end + x = 64'hB7F00003FFFFE000; + y = 64'h3FCF7F2EBA57F364; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2454157\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h405C0023F12D5E3D; + ans = 64'h4340000000000037; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2454771\n"); + end + x = 64'h7FD004007FFFFFFF; + y = 64'hC020000000008001; + z = 64'hC80BDBDBDC204CF5; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2455385\n"); + end + x = 64'h480EFB187297B81E; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2455999\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h43F00B8D04784AC1; + z = 64'h3FBFFFFFEE000000; + ans = 64'h47500B8D04784AC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2456613\n"); + end + x = 64'hCC6FFF8000000001; + y = 64'h3FE0000000000001; + z = 64'hBFA27E00240AF10F; + ans = 64'hCC5FFF8000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2457227\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC1FFFF0FFFFFFFFF; + z = 64'h4000000000000000; + ans = 64'hC55FFF0FFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2457841\n"); + end + x = 64'h40AFFFFFFFFFFCFE; + y = 64'h380000000000017F; + z = 64'h000E30BD8369AC4B; + ans = 64'h38BFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2458455\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hC010000000000000; + ans = 64'h434FFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2459069\n"); + end + x = 64'h7FEFFFFFFEFFFFBF; + y = 64'h401FBFFFFC000000; + z = 64'hBCA0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2459683\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h3FF0000000000001; + z = 64'hFFD7E4BB7A2E0326; + ans = 64'hFFD7E4BB7A2E0326; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2460297\n"); + end + x = 64'h45EE2D3BC6E262EA; + y = 64'h37FFFFFFFF7FFEFF; + z = 64'h3FD774F0EF62E768; + ans = 64'h3FD774F0EFDB9C57; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2460911\n"); + end + x = 64'h3F3F7FFFF8000000; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2461525\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h4C7FFFFFF7FFFFFE; + z = 64'hC010000000800100; + ans = 64'h4FDFFFFFF7FFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2462139\n"); + end + x = 64'hC010100001000000; + y = 64'h4000000000000000; + z = 64'hC07FFFFFFF7FFEFF; + ans = 64'hC080403FFFC3FF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2462753\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h47EFFFFFFFFF7F80; + z = 64'h3FF0000000000001; + ans = 64'h4B4FFFFFFFFF7F7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2463367\n"); + end + x = 64'h3FCD3AEC7123E6D4; + y = 64'hC040FFFFFFFFFFFF; + z = 64'h41700008000FFFFE; + ans = 64'h4170000783D5931D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2463981\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hC000000000000001; + ans = 64'h436FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2464595\n"); + end + x = 64'h270F000000FFFFFF; + y = 64'h41CE3457B589E945; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h28ED42B4F8CF3CB8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2465209\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h4010000000000000; + z = 64'hC03FFBFFF0000000; + ans = 64'h436FFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2465823\n"); + end + x = 64'hC3D00003FEFFFFFF; + y = 64'hB7EFFFFFFFFFF001; + z = 64'h3FF0400000000001; + ans = 64'h3FF0400000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2466437\n"); + end + x = 64'h78B000000203FFFF; + y = 64'h4010000000000001; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'h78D0000002040000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2467051\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h41CFFFF3FFFFFFFF; + z = 64'h38FFFFFFFFFFFF82; + ans = 64'h452FFFF3FFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2467665\n"); + end + x = 64'hBFF76194103CAB16; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hFFE0BFFFFFFFFFFE; + ans = 64'hFFE0BFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2468279\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h401003FEFFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h437003FEFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2468893\n"); + end + x = 64'hC1000F8D71DACA50; + y = 64'h7BD00000000047FF; + z = 64'h434836306FD629E2; + ans = 64'hFCE00F8D71DB1295; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2469507\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h4340000000000001; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h46A0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2470121\n"); + end + x = 64'h8BC20000000001FE; + y = 64'h47F0000FFFFDFFFF; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h93C20011FFFDC1FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2470735\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC01E007FFFFFFFFF; + ans = 64'h46AFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2471349\n"); end x = 64'hC34FFFFFFFFFFC00; y = 64'hBBE000000000027F; @@ -57659,12 +189259,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2469163\n"); + $fwrite(fp,"2471963\n"); end - x = 64'h434FFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; + x = 64'h381E94E42BF42E17; + y = 64'h7FE0000000000000; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'h780E94E42BF42E17; rn = 1; rz = 0; rm = 0; @@ -57706,12 +189306,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2471177\n"); + $fwrite(fp,"2472577\n"); end - x = 64'hC7EFFB7FFFFFFFFF; - y = 64'h7FF0000000000001; - z = 64'h41D0003FFFFFFFC0; - ans = 64'h7FF8000000000001; + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC0600000021FFFFF; + z = 64'h387007FFFFFFFFFA; + ans = 64'hC3C00000021FFFFE; rn = 1; rz = 0; rm = 0; @@ -57755,761 +189355,9 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"2473191\n"); end - x = 64'h800FFFFFFDFFFFFF; - y = 64'hBFCFFE00003FFFFE; - z = 64'h800FFFF01FFFFFFE; - ans = 64'h800C00302077F7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2475205\n"); - end - x = 64'h434FFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2477219\n"); - end - x = 64'hC017FF8000000000; - y = 64'h8010000000000000; - z = 64'hBFCFFFFFFF820000; - ans = 64'hBFCFFFFFFF820000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2479233\n"); - end - x = 64'hCAEBFFFFFFFFFF7F; - y = 64'h43C5000000000000; - z = 64'hBFB00003FFFDFFFE; - ans = 64'hCEC25FFFFFFFFFAB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2481247\n"); - end - x = 64'h434FFFFFFFFFFFFE; - y = 64'hBCA0000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2483261\n"); - end - x = 64'h802A548D6271A8D4; - y = 64'hBFD0000000000000; - z = 64'h4010005000000000; - ans = 64'h4010005000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2485275\n"); - end - x = 64'hC0EFFAFFFFFFFFFF; - y = 64'h3F1FFBFFFFFFFDFF; - z = 64'hBFC929330A6F28FB; - ans = 64'hC02060251C29BBA3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2487289\n"); - end - x = 64'h434FFFFFFFFFFFFE; - y = 64'hBFE0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2489303\n"); - end - x = 64'hBFF007F7FFFFFFFF; - y = 64'hBFF0000000000000; - z = 64'h3ED10000007FFFFE; - ans = 64'h3FF007FC4000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2491317\n"); - end - x = 64'h401FFFFFFBFFFBFF; - y = 64'h3FBFFFEF80000000; - z = 64'hC00000400000007F; - ans = 64'hBFF00088420001F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2493331\n"); - end - x = 64'h434FFFFFFFFFFFFE; - y = 64'hC000000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2495345\n"); - end - x = 64'hBF3FFFFFDC000000; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hBEF00000000043FE; - ans = 64'h3F5FBFFFDBFFFEEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2497359\n"); - end - x = 64'h0F2FDFEFFFFFFFFF; - y = 64'h3A7FFFFFFDFF7FFF; - z = 64'hC09C6DB48153D631; - ans = 64'hC09C6DB48153D631; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2499373\n"); - end - x = 64'h434FFFFFFFFFFFFE; - y = 64'hC340000000000000; - z = 64'hBFF0000000000001; - ans = 64'hC69FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2501387\n"); - end - x = 64'h47E0000037FFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'hBFFEFFFFFFBFFFFE; - ans = 64'hCB40000037FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2503401\n"); - end - x = 64'h41D47345FAF3A236; - y = 64'hBCA000EFFFFFFFFE; - z = 64'h401E32064EC9BA5F; - ans = 64'h401E3206448F7E01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2505415\n"); - end - x = 64'h434FFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - z = 64'h4340000000000000; + x = 64'hC1FFFFFFFE1FFFFE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hB7FFFFFFFBFFFFBF; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -58552,12 +189400,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2507429\n"); + $fwrite(fp,"2473805\n"); end - x = 64'hBFFFC000000FFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h7FE400000003FFFF; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h434FFFFFFFFFFFFE; + y = 64'h766C7FFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h79CC7FFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -58599,12 +189447,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2509443\n"); + $fwrite(fp,"2474419\n"); end - x = 64'hBD2D87ECBE7232FC; - y = 64'h46FFFFD7FFFFFFFF; - z = 64'h3C8FC000FFFFFFFF; - ans = 64'hC43D87C7D48A44EC; + x = 64'hC34FFFFFFFFFFC07; + y = 64'hB810000200001000; + z = 64'hC7A000000000004E; + ans = 64'hC7A000000000004E; rn = 1; rz = 0; rm = 0; @@ -58646,434 +189494,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2511457\n"); + $fwrite(fp,"2475033\n"); end - x = 64'h7FE0000000000000; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2513471\n"); - end - x = 64'hC6EA598C18FEC705; - y = 64'h001FFFFFFFFFFFFF; - z = 64'hC4F8080000000000; - ans = 64'hC4F8080000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2515485\n"); - end - x = 64'hBFFBEA8B82A394CD; - y = 64'h43D3EF2684B3792F; - z = 64'h3FEFFFFF0001FFFF; - ans = 64'hC3E163E431D2926A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2517499\n"); - end - x = 64'h7FE0000000000000; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7C9FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2519513\n"); - end - x = 64'h445FF7FFEFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h41EFEFFFFFFFFFF6; - ans = 64'h444FF7FFF0007FBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2521527\n"); - end - x = 64'hBD5EC6885C477DBA; - y = 64'hB81FFFFC00000008; - z = 64'hBE5EAB9C5EE587B9; - ans = 64'hBE5EAB9C5EE587B9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2523541\n"); - end - x = 64'h7FE0000000000000; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h7FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2525555\n"); - end - x = 64'hC01010001FFFFFFF; - y = 64'h3FF0000000000001; - z = 64'h43FFFFFFFFE1FFFE; - ans = 64'h43FFFFFFFFE1FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2527569\n"); - end - x = 64'h4180000000000406; - y = 64'h9630FE0000000000; - z = 64'hC01FFFFFF0000007; - ans = 64'hC01FFFFFF0000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2529583\n"); - end - x = 64'h7FE0000000000000; - y = 64'h400FFFFFFFFFFFFF; - z = 64'hC340000000000000; + x = 64'h434FFFFFFFFFFFFE; + y = 64'h7FF0000000000000; + z = 64'hBFEFFFFFFFFFFFFE; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -59116,12 +189541,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2531597\n"); + $fwrite(fp,"2475647\n"); end - x = 64'hBD7EC05DFC32DDF5; - y = 64'h4010000000000001; - z = 64'hC3E01FEFFFFFFFFE; - ans = 64'hC3E01FEFFFFFFFFE; + x = 64'hBFEFE00008000000; + y = 64'hCE7000FFFFFBFFFE; + z = 64'h8000000000000000; + ans = 64'h4E6FE1FE07F887FC; rn = 1; rz = 0; rm = 0; @@ -59163,199 +189588,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2533611\n"); + $fwrite(fp,"2476261\n"); end - x = 64'hC0C201D33203D333; - y = 64'hC3DFF00000007FFF; - z = 64'h381000001F7FFFFF; - ans = 64'h44B1F8D2486B1950; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2535625\n"); - end - x = 64'h7FE0000000000000; - y = 64'h434FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2537639\n"); - end - x = 64'h40512DA7BCF2D356; - y = 64'h7FE0000000000001; - z = 64'hBFFFFFBFFFFFFFBF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2539653\n"); - end - x = 64'hC1EFFFFFFFFF1FFE; - y = 64'h400EFFFFFDFFFFFF; - z = 64'h56D000FDFFFFFFFF; - ans = 64'h56D000FDFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2541667\n"); - end - x = 64'h7FE0000000000000; + x = 64'h434FFFFFFFFFFFFE; y = 64'h7FFFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; + z = 64'h40DFFFFC00020000; ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -59398,12 +189635,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2543681\n"); + $fwrite(fp,"2476875\n"); end - x = 64'hF4F000000000F800; - y = 64'h8000000000000000; - z = 64'h40C0043FFFFFFFFF; - ans = 64'h40C0043FFFFFFFFF; + x = 64'h2CFFFFFFEE000000; + y = 64'hBCAFFFFFFBFFFF80; + z = 64'hE29FFFFE000FFFFF; + ans = 64'hE29FFFFE000FFFFF; rn = 1; rz = 0; rm = 0; @@ -59445,904 +189682,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2545695\n"); + $fwrite(fp,"2477489\n"); end - x = 64'hC1B00800FFFFFFFF; - y = 64'hC076927C86FDAFBF; - z = 64'hBF80001EFFFFFFFF; - ans = 64'h42369DC72E68F505; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2547709\n"); - end - x = 64'h7FE0000000000000; - y = 64'h8010000000000001; - z = 64'hBFF0000000000001; - ans = 64'hC008000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2549723\n"); - end - x = 64'h400FFFFDF0000000; - y = 64'hBCA0000000000000; - z = 64'hC20CBD47BB1ACD33; - ans = 64'hC20CBD47BB1ACD33; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2551737\n"); - end - x = 64'h43410000007FFFFF; - y = 64'hBEE462F95CA516E0; - z = 64'h2EDFFFFFFDFFFBFE; - ans = 64'hC235A928F3128018; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2553751\n"); - end - x = 64'h7FE0000000000000; - y = 64'hBFD0000000000001; - z = 64'h4340000000000000; - ans = 64'hFFC0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2555765\n"); - end - x = 64'h5BB38757B6D1035E; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hC7FFFFDFF0000000; - ans = 64'hDBA38757B6D1035D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2557779\n"); - end - x = 64'h3FA000083FFFFFFF; - y = 64'hC0236A374BC6D622; - z = 64'h7FFD20EAEDAEB318; - ans = 64'h7FFD20EAEDAEB318; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2559793\n"); - end - x = 64'h7FE0000000000000; - y = 64'hBFF0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2561807\n"); - end - x = 64'hBFD0008FFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hC7F0003FFFFFFFBF; - ans = 64'hC7F0003FFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2563821\n"); - end - x = 64'hBFB5C3596BC996A8; - y = 64'h2418829CEEE07D74; - z = 64'h2F18000000001FFF; - ans = 64'h2F18000000001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2565835\n"); - end - x = 64'h7FE0000000000000; - y = 64'hC010000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2567849\n"); - end - x = 64'h47FEB3CE3683C2DE; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h403FFFFFDFFEFFFF; - ans = 64'hC82EB3CE3683C2DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2569863\n"); - end - x = 64'h4044AD4CBA8C54EB; - y = 64'h939FFFDFFFEFFFFF; - z = 64'hC0AFFF000003FFFF; - ans = 64'hC0AFFF000003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2571877\n"); - end - x = 64'h7FE0000000000000; - y = 64'hFFE0000000000000; - z = 64'h3FF0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2573891\n"); - end - x = 64'h40300007FFFF0000; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'h7713FFFFFFFFFFEE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2575905\n"); - end - x = 64'h002A8A671164C4C0; - y = 64'hBFD000FFFDFFFFFF; - z = 64'h41701000000000FF; - ans = 64'h41701000000000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2577919\n"); - end - x = 64'h7FE0000000000000; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2579933\n"); - end - x = 64'h91FFA5AB434ED1A6; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hC02FFFDFFFF7FFFF; - ans = 64'hC02FFFDFFFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2581947\n"); - end - x = 64'h40F89870592100EB; - y = 64'h380FFFFE00000040; - z = 64'h3FFFF8003FFFFFFE; - ans = 64'h3FFFF8003FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2583961\n"); - end - x = 64'h7FE0000000000001; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; + x = 64'h3C70000001FFFFFA; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC010000000000000; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -60385,12 +189729,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2585975\n"); + $fwrite(fp,"2478103\n"); end - x = 64'hBD7000400000003F; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'hC3DFFFFE03FFFFFE; - ans = 64'hC3DFFFFE03FFFFFE; + x = 64'h434FFFFFFFFFFFFE; + y = 64'h417F8000000003FF; + z = 64'h41CFFFFFFFFDFFFF; + ans = 64'h44DF80000000040D; rn = 1; rz = 0; rm = 0; @@ -60432,623 +189776,999 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2587989\n"); + $fwrite(fp,"2478717\n"); end - x = 64'hC0000001000003FE; - y = 64'hFFEF7FBFFFFFFFFF; - z = 64'hC08637FF3FC3CF17; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2590003\n"); - end - x = 64'h7FE0000000000001; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2592017\n"); - end - x = 64'h3FB00000000FFFFE; - y = 64'h3FE0000000000001; - z = 64'h413001FFDFFFFFFF; - ans = 64'h413001FFE7FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2594031\n"); - end - x = 64'h001FFFFF003FFFFE; - y = 64'hC02FFFFE7FFFFFFF; - z = 64'hC0232C4C60814675; - ans = 64'hC0232C4C60814675; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2596045\n"); - end - x = 64'h7FE0000000000001; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2598059\n"); - end - x = 64'hFFF00FFDB3690C59; - y = 64'h4000000000000001; - z = 64'h3BC3D6DDE1AFB256; - ans = 64'hFFF80FFDB3690C59; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2600073\n"); - end - x = 64'hB8E000FFFFFFFFFC; - y = 64'hBE100000007FFBFF; - z = 64'h3CA000010001FFFF; - ans = 64'h3CA000010001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2602087\n"); - end - x = 64'h7FE0000000000001; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2604101\n"); - end - x = 64'hC08FFFFFFFE000FF; - y = 64'h4340000000000000; - z = 64'hBB70000000400080; - ans = 64'hC3DFFFFFFFE000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2606115\n"); - end - x = 64'h5F5FFEFFFFFFFF7F; - y = 64'h4020200002000000; - z = 64'hC1CF42BE33A182EE; - ans = 64'h5F901F7F01FFEFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2608129\n"); - end - x = 64'h7FE0000000000001; - y = 64'h7FE0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2610143\n"); - end - x = 64'h52225CBAA881CC61; - y = 64'h7FF0000000000000; - z = 64'hBFB0000000001003; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2612157\n"); - end - x = 64'h39BFFFFFFFEFFFBF; - y = 64'hBFC007FFF7FFFFFF; - z = 64'hB49000000000000A; - ans = 64'hB99007FFF7F7FBDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2614171\n"); - end - x = 64'h7FE0000000000001; + x = 64'hBC0FF000000007FF; y = 64'h8000000000000001; + z = 64'h40BFFFFDFFFFBFFF; + ans = 64'h40BFFFFDFFFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2479331\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC28FFFFFFFC00000; + z = 64'h3FD0000000000000; + ans = 64'hC5EFFFFFFFBFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2479945\n"); + end + x = 64'hBFA080FFFFFFFFFF; + y = 64'h3D14FE4D81C77FAF; + z = 64'h3FC0C75B734A8881; + ans = 64'h3FC0C75B734A886B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2480559\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2481173\n"); + end + x = 64'h000000001FEFFFFF; + y = 64'hC01FF80000000000; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2481787\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h8010000000000001; + z = 64'h4030003FFFFDFFFF; + ans = 64'h4030003FFFFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2482401\n"); + end + x = 64'hD8A00004003FFFFF; + y = 64'h3F3FFFEF7FFFFFFF; + z = 64'hFFE008000000FFFE; + ans = 64'hFFE008000000FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2483015\n"); + end + x = 64'hC1F0003EFFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2483629\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h47F2990F0D3AB431; + z = 64'h393D2F8E7A9FABB8; + ans = 64'h4B52990F0D3AB430; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2484243\n"); + end + x = 64'h403000003FBFFFFF; + y = 64'hBCA0000000000000; + z = 64'hB81E0000001FFFFE; + ans = 64'hBCE000003FBFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2484857\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC04FF800000003FF; + z = 64'h3CA0000000000001; + ans = 64'hC3AFF800000003FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2485471\n"); + end + x = 64'hBF0C50CD67902869; + y = 64'h403BFFC000000000; + z = 64'h40A04000007FFFFF; + ans = 64'h40A03FFF3A4C2737; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2486085\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hBFD0000000000001; + ans = 64'hC010FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2486699\n"); + end + x = 64'hFFDFBBFFFFFFFFFE; + y = 64'hBE9FFFFFF80007FF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2487313\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hBFD0000000000000; + z = 64'hC1F0000080001000; + ans = 64'hC3300001000007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2487927\n"); + end + x = 64'hC03FFBFFEFFFFFFE; + y = 64'hBD21FFFFFFFFFDFF; + z = 64'h43EF800040000000; + ans = 64'h43EF800040000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2488541\n"); + end + x = 64'hB7F0000000024000; + y = 64'hBFD0000000000001; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2489155\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h000F800001FFFFFE; + z = 64'h47F00000007F8000; + ans = 64'h47F00000007F8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2489769\n"); + end + x = 64'h7FE244C23A3D6EAE; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h9B2FFFFFFFFFEDFF; + ans = 64'hFFD244C23A3D6EAD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2490383\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h4FA9881599BF1A5B; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h5309881599BF1A59; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2490997\n"); + end + x = 64'h381FFFFFFFFFDEFF; + y = 64'h49CFBFF7FFFFFFFF; + z = 64'h3FE898FF0DEE5590; + ans = 64'h41FFBFF8000C2BC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2491611\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hBFE0000000000001; z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCC8000000000001; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -61090,12 +190810,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2616185\n"); + $fwrite(fp,"2492225\n"); end - x = 64'hCC5FFC01FFFFFFFF; - y = 64'h8010000000000000; - z = 64'hC06E05881E1A05C1; - ans = 64'hC06E05881E1A05C1; + x = 64'hC0303FFFFFFFFE00; + y = 64'h7FDFFFFFEF7FFFFF; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -61137,247 +190857,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2618199\n"); + $fwrite(fp,"2492839\n"); end - x = 64'hBF800001000001FF; - y = 64'hFFF00000001FFF7E; - z = 64'hC1DFFFFFFFF807FE; - ans = 64'hFFF80000001FFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2620213\n"); - end - x = 64'h7FE0000000000001; - y = 64'hBCA0000000000001; - z = 64'h3FF0000000000001; - ans = 64'hFC90000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2622227\n"); - end - x = 64'h3A7B7160CB764D1B; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h407000004000FFFF; - ans = 64'h407000004000FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2624241\n"); - end - x = 64'hC03000000000FF00; - y = 64'hBFBFFFFEFFFC0000; - z = 64'h36C0008007FFFFFF; - ans = 64'h3FFFFFFEFFFDFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2626255\n"); - end - x = 64'h7FE0000000000001; - y = 64'hBFE0000000000000; - z = 64'hC340000000000000; - ans = 64'hFFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2628269\n"); - end - x = 64'h1C100000FFFFFFFD; + x = 64'h434FFFFFFFFFFFFE; y = 64'hBFEFFFFFFFFFFFFE; - z = 64'h50681FB9473AA1DB; - ans = 64'h50681FB9473AA1DB; + z = 64'hBFBDFFFFFFFFFFDE; + ans = 64'hC34FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -61419,12 +190904,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2630283\n"); + $fwrite(fp,"2493453\n"); end - x = 64'h3FFFFFFFFFFFBFEF; - y = 64'hFFFFFFFFFEFFFFFF; - z = 64'h3FCFFC000000007E; - ans = 64'hFFFFFFFFFEFFFFFF; + x = 64'h3CA2DEE9CC137D78; + y = 64'hC340000000008000; + z = 64'h3C4A51233EDE3650; + ans = 64'hBFF2DEE9CC14146F; rn = 1; rz = 0; rm = 0; @@ -61466,12 +190951,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2632297\n"); + $fwrite(fp,"2494067\n"); end - x = 64'h7FE0000000000001; + x = 64'hC01C622D64A3288A; + y = 64'hBFF0000000000000; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h4018622D64A3288A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2494681\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h4030002000FFFFFE; + z = 64'h6C6000000007F800; + ans = 64'h6C6000000007F800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2495295\n"); + end + x = 64'h97938A198628AFDE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3CA1FFFFFFFFDFFF; + ans = 64'h3CA1FFFFFFFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2495909\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h499FFFFFFFFEFFFE; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h4CFFFFFFFFFEFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2496523\n"); + end + x = 64'hBFB71435A3DCB677; + y = 64'hBFBFFFF7FFFFFF7F; + z = 64'hC0503FFF7FFFFFFE; + ans = 64'hC0503F46DE810984; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2497137\n"); + end + x = 64'h434FFFFFFFFFFFFE; y = 64'hC000000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hC35FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -61513,388 +191233,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2634311\n"); + $fwrite(fp,"2497751\n"); end - x = 64'h381FFFFFFFE0FFFE; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hC34FFFFFFFEFFEFE; - ans = 64'hC34FFFFFFFEFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2636325\n"); - end - x = 64'h405000000800007F; - y = 64'h400FFFFFFFC001FF; - z = 64'hC3F00007FFFFFFE0; - ans = 64'hC3F00007FFFFFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2638339\n"); - end - x = 64'h7FE0000000000001; - y = 64'hC340000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2640353\n"); - end - x = 64'h43EC0D35899D926D; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hBCA000027FFFFFFF; - ans = 64'hC74C0D35899D926C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2642367\n"); - end - x = 64'hC22000000001FFE0; - y = 64'h176FFFEFFFFFF7FE; - z = 64'h490FFFFFFFF7FFFF; - ans = 64'h490FFFFFFFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2644381\n"); - end - x = 64'h7FE0000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2646395\n"); - end - x = 64'h43F01001FFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h40201FDFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2648409\n"); - end - x = 64'hFFFA2472BB86DDE6; - y = 64'h380000000000800F; - z = 64'hCC2FFFBFFFFFFBFE; - ans = 64'hFFFA2472BB86DDE6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2650423\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFE; + x = 64'hC033F17FAAA569B5; + y = 64'hC34EFFFFFFFFFFDE; z = 64'h4340000000000000; - ans = 64'h4340000000000002; + ans = 64'h4393D1F3AD503E52; rn = 1; rz = 0; rm = 0; @@ -61936,12 +191280,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2652437\n"); + $fwrite(fp,"2498365\n"); end - x = 64'hFFD0007FFFFFFFFF; - y = 64'h0010000000000001; - z = 64'h43BFF293676FA42F; - ans = 64'h43BFF293676FA42F; + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h801FFFFFFFF7FFBE; + ans = 64'hC36FFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -61983,12 +191327,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2654451\n"); + $fwrite(fp,"2498979\n"); end - x = 64'hCF6FFFFFEFFFFFFB; - y = 64'hC3FFFBF800000000; - z = 64'h3FB0001010000000; - ans = 64'h537FFBF7F00203FB; + x = 64'h4B82DA79B78A7C5C; + y = 64'hFFF8F12536538EFF; + z = 64'hC01FFC0000000100; + ans = 64'hFFF8F12536538EFF; rn = 1; rz = 0; rm = 0; @@ -62030,11 +191374,951 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2656465\n"); + $fwrite(fp,"2499593\n"); end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; + x = 64'hBB7F4BAC4BBA9910; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2500207\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h401FC147E4167F25; + z = 64'h407B43BA65F2A73B; + ans = 64'h437FC147E4167F3E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2500821\n"); + end + x = 64'hBFDDD9E98A3D34F9; + y = 64'hC010000000000001; + z = 64'hC3DD470895062963; + ans = 64'hC3DD470895062963; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2501435\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h7FEFBFFFF7FFFFFF; + z = 64'h0000000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2502049\n"); + end + x = 64'hC3FFFFFF000FFFFF; + y = 64'h7FF07FFFFFFE0000; + z = 64'h43CFFFFFFFFFDFFE; + ans = 64'h7FF87FFFFFFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2502663\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h8010000000000000; + ans = 64'hC37FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2503277\n"); + end + x = 64'h7FF0000000FFBFFF; + y = 64'hA9A0001FFFFFFFF8; + z = 64'h4010000000000001; + ans = 64'h7FF8000000FFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2503891\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC340000000000001; + z = 64'hBCA3FFFFFFFF7FFE; + ans = 64'hC6A0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2504505\n"); + end + x = 64'h3D00800000000002; + y = 64'hC06FFFFFE00003FF; + z = 64'hB81CC3048B84E23F; + ans = 64'hBD807FFFEF800211; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2505119\n"); + end + x = 64'h434FE0000007FFFF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hBFD0000000000001; + ans = 64'hC6AFE0000007FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2505733\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hFFDFFEFEFFFFFFFF; + z = 64'h399D95938DB130F5; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2506347\n"); + end + x = 64'h43FF0AD19973161F; + y = 64'hFFE0000000000000; + z = 64'h41E0000000002FFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2506961\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC00FEFFFFFFFFDFF; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2507575\n"); + end + x = 64'hBFC000107FFFFFFF; + y = 64'h380FBFFFFFFFFDFF; + z = 64'h43403FFFFFFF8000; + ans = 64'h43403FFFFFFF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2508189\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h8000000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2508803\n"); + end + x = 64'hC0500003FFFFFEFE; + y = 64'hC2311EB7C65185DC; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h42911EBC0DFF865C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2509417\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hFFF0000000000000; + z = 64'h90DFFFFFC3FFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2510031\n"); + end + x = 64'hC1D866C6E8E78AA0; + y = 64'hBE0E00000007FFFF; + z = 64'hC0EFFFFEFFFFFFBE; + ans = 64'hC0EFFFD13F4B0B00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2510645\n"); + end + x = 64'h001FFC000000FFFE; + y = 64'hFFF0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2511259\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h364FFFFFF807FFFF; + z = 64'h400FFFFFFBFFFBFF; + ans = 64'h400FFFFFFBFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2511873\n"); + end + x = 64'h7FEBFFDFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h5A0FFFFEFFFF7FFF; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -62077,951 +192361,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2658479\n"); + $fwrite(fp,"2512487\n"); end - x = 64'h3FAFFFFFFFFBFEFF; - y = 64'h3FD0000000000001; - z = 64'h43F0001FFEFFFFFF; - ans = 64'h43F0001FFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2660493\n"); - end - x = 64'h3FEFFFFFFE0007FF; - y = 64'h43F70A25E925FA1F; - z = 64'h47F7FC40693B3066; - ans = 64'h47F7FC40693B3066; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2662507\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2664521\n"); - end - x = 64'hBFD3CDC9C82B0594; - y = 64'h3FF0000000000001; - z = 64'h801FFFFF7FF7FFFF; - ans = 64'hBFD3CDC9C82B0595; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2666535\n"); - end - x = 64'h41EFFFFFFFEFFFF0; - y = 64'h434FFFFFFFFAFFFF; - z = 64'h37EF5CAE32DE4414; - ans = 64'h454FFFFFFFEAFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2668549\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2670563\n"); - end - x = 64'h0014E05E573858BA; - y = 64'h4010000000000000; - z = 64'hDA8000003FFFBFFE; - ans = 64'hDA8000003FFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2672577\n"); - end - x = 64'h380FFEFFFFFDFFFF; - y = 64'hC02F4361FFA13654; - z = 64'hC0CFFFFE0000007F; - ans = 64'hC0CFFFFE0000007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2674591\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'h4340000000000001; - z = 64'hC340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2676605\n"); - end - x = 64'h3FB00000003FBFFF; - y = 64'h7FE0000000000000; - z = 64'h4F81FFFFFFFFDFFF; - ans = 64'h7FA00000003FBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2678619\n"); - end - x = 64'h43412867894A0DC5; - y = 64'hC3F94739873DE8C1; - z = 64'h3FCBFFDFFFFFFFFF; - ans = 64'hC74B1B82C2ED1473; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2680633\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'h7FF0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2682647\n"); - end - x = 64'hBFC00003FE000000; - y = 64'h8000000000000000; - z = 64'h43D68C73218D34AD; - ans = 64'h43D68C73218D34AD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2684661\n"); - end - x = 64'h4DF2000000200000; - y = 64'hBCAE00001FFFFFFE; - z = 64'h428FFFFFFF800FFE; - ans = 64'hCAB0E000121DFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2686675\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'h8010000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2688689\n"); - end - x = 64'h7FF07FFDFFFFFFFE; - y = 64'h801FFFFFFFFFFFFE; - z = 64'hBFBB25BD3D7D1912; - ans = 64'h7FF87FFDFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2690703\n"); - end - x = 64'h47900000081FFFFF; - y = 64'h5760040000001FFF; - z = 64'h405FFFC03FFFFFFF; - ans = 64'h5F000400082227FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2692717\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'hBFD0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hFFCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2694731\n"); - end - x = 64'hB7F001000000003E; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hB7F00000004001FF; - ans = 64'hB7DFFE0001000782; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2696745\n"); - end - x = 64'hC01FC000FFFFFFFF; - y = 64'hBFEFF0001FFFFFFF; - z = 64'h406BFFEFFFFFFFFE; - ans = 64'h406CFD7108FA0006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2698759\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'hBFF0000000000000; - z = 64'h4340000000000000; + x = 64'h434FFFFFFFFFFFFE; + y = 64'h497FFBFFFEFFFFFF; + z = 64'hFFEFFFFFFFFFFFFF; ans = 64'hFFEFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -63064,12 +192408,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2700773\n"); + $fwrite(fp,"2513101\n"); end - x = 64'h42CF0007FFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h43FFFB7FFFFFFFFF; - ans = 64'h43FFFB783FFDFFFF; + x = 64'hAC2000000200003E; + y = 64'h418FFFFDFFFFFBFF; + z = 64'h001FBFFFFFEFFFFF; + ans = 64'hADBFFFFE03FFFC3B; rn = 1; rz = 0; rm = 0; @@ -63111,388 +192455,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2702787\n"); + $fwrite(fp,"2513715\n"); end - x = 64'hB80FFDFFFFFEFFFF; - y = 64'h381000000040001F; - z = 64'h3FD00000003FFFFF; - ans = 64'h3FD00000003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2704801\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2706815\n"); - end - x = 64'h5760000004000001; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h3FFFFFFF7FFFE000; - ans = 64'hD790000004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2708829\n"); - end - x = 64'hC57F7FFBFFFFFFFF; - y = 64'hBFC0200004000000; - z = 64'h7FFFFFFFFF9FFFFE; - ans = 64'h7FFFFFFFFF9FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2710843\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2712857\n"); - end - x = 64'hBF500000000803FF; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'h3FFB0E4708FCD9C5; - ans = 64'h7F500000000803FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2714871\n"); - end - x = 64'hC34FFFFFFF7FBFFE; - y = 64'h37F0000000401000; - z = 64'h40AFFFFE0000007F; - ans = 64'h40AFFFFE0000007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2716885\n"); - end - x = 64'h7FEFFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2718899\n"); - end - x = 64'h37F0000020000FFE; + x = 64'h7FE0000000000000; y = 64'h0000000000000001; - z = 64'hB7E000FFEFFFFFFF; - ans = 64'hB7E000FFEFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -63534,12 +192502,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2720913\n"); + $fwrite(fp,"2514329\n"); end - x = 64'h401FFFFFF7DFFFFE; - y = 64'hDD9000000010003F; - z = 64'h380FFF7F7FFFFFFF; - ans = 64'hDDBFFFFFF800007C; + x = 64'h001FFFFFFFFFFFE6; + y = 64'hC00FEFDFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -63581,12 +192549,670 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2722927\n"); + $fwrite(fp,"2514943\n"); end - x = 64'h7FEFFFFFFFFFFFFE; + x = 64'h7FE0000000000000; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hC0200005FFFFFFFF; + ans = 64'hC018000BFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2515557\n"); + end + x = 64'h59F0000040003FFE; + y = 64'hC010003800000000; + z = 64'h57C1FEFFFFFFFFFF; + ans = 64'hDA10003840009007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2516171\n"); + end + x = 64'hC3CFC00800000000; + y = 64'h0010000000000000; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h83EFC00800000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2516785\n"); + end + x = 64'h7FE0000000000000; + y = 64'hC03508327EAAA217; + z = 64'h3F700400000003FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2517399\n"); + end + x = 64'h2838382127EC1F47; y = 64'h001FFFFFFFFFFFFF; + z = 64'hC42FFFFC00000001; + ans = 64'hC42FFFFC00000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2518013\n"); + end + x = 64'h7FE0000000000000; + y = 64'h4B70000000400800; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2518627\n"); + end + x = 64'h3FFF1FFFFFFFFFFF; + y = 64'h4140000000FFFFEE; + z = 64'h400FFFFFFFE1FFFE; + ans = 64'h414F200201F1FFDA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2519241\n"); + end + x = 64'h7FE0000000000000; + y = 64'h3CA0000000000000; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2519855\n"); + end + x = 64'hBD2002FFFFFFFFFF; + y = 64'h802989E4FD4682E9; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2520469\n"); + end + x = 64'h7FE0000000000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h47E8C5BFE3AE8110; + ans = 64'h7C9FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2521083\n"); + end + x = 64'hC0300000001FFFBF; + y = 64'h398FFFFEFFFFF800; + z = 64'hBEF00001FFFBFFFF; + ans = 64'hBEF00001FFFBFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2521697\n"); + end + x = 64'hC025AA627143737D; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h8010000000000000; + ans = 64'hBCE5AA627143737C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2522311\n"); + end + x = 64'h7FE0000000000000; + y = 64'h43C0000003F7FFFE; + z = 64'hC800000004000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2522925\n"); + end + x = 64'hBFFFFFFFF7FFFFFE; + y = 64'h3FD0000000000001; + z = 64'hC7E55EFA4B05F9A4; + ans = 64'hC7E55EFA4B05F9A4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2523539\n"); + end + x = 64'h7FE0000000000000; + y = 64'h43F000080001FFFE; z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFF8; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -63628,12 +193254,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2724941\n"); + $fwrite(fp,"2524153\n"); end - x = 64'hC060003FFFFF7FFE; - y = 64'h3CA0000000000001; - z = 64'hC02000FFFEFFFFFE; - ans = 64'hC02000FFFF000006; + x = 64'hB80103FFFFFFFFFF; + y = 64'h3FDE95FBB84960D4; + z = 64'h401FFFFF8FFFFFFF; + ans = 64'h401FFFFF8FFFFFFF; rn = 1; rz = 0; rm = 0; @@ -63675,12 +193301,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2726955\n"); + $fwrite(fp,"2524767\n"); end - x = 64'h3FDFFFFFFFBEFFFF; - y = 64'h5A9100000003FFFF; - z = 64'h8018800000000000; - ans = 64'h5A80FFFFFFE177FE; + x = 64'h7FE0000000000000; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h7FE0000000000000; + ans = 64'h7FE8000000000000; rn = 1; rz = 0; rm = 0; @@ -63722,11 +193348,1656 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2728969\n"); + $fwrite(fp,"2525381\n"); end - x = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; + x = 64'hC02DFBFFFFFFFFFF; + y = 64'hCAADFFFFFFFFFFDF; + z = 64'h3FE0000000000001; + ans = 64'h4AEC1C3FFFFFFFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2525995\n"); + end + x = 64'h7FE0000000000000; + y = 64'h3FE0000000000000; + z = 64'h9A30ABB2E44153EF; + ans = 64'h7FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2526609\n"); + end + x = 64'h3DC0CBF5120273C1; + y = 64'hBFDFFC0000000002; + z = 64'hBFDEFFFFFFFFFFFE; + ans = 64'hBFDF000000043275; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2527223\n"); + end + x = 64'hCA7FEFF7FFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h8000000000000001; + ans = 64'hCA7FEFF7FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2527837\n"); + end + x = 64'h7FE0000000000000; + y = 64'hC03FFFF9FFFFFFFE; + z = 64'h3D5FFFFFFFFB7FFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2528451\n"); + end + x = 64'h3FE002FFFFFFFFFF; + y = 64'h3FF0000000000000; + z = 64'hC050000000010003; + ans = 64'hC04FBFF400020006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2529065\n"); + end + x = 64'h7FE0000000000000; + y = 64'hC78FFFFE000003FF; + z = 64'hC010000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2529679\n"); + end + x = 64'h402FF7FDFFFFFFFE; + y = 64'hCC7FEFFFFFFFF800; + z = 64'h41C001000000003F; + ans = 64'hCCBFE80200FFF800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2530293\n"); + end + x = 64'h7FE0000000000000; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h4340000000000001; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2530907\n"); + end + x = 64'h401AF433A5C310C2; + y = 64'hFFFF000000001000; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'hFFFF000000001000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2531521\n"); + end + x = 64'h7FE0000000000000; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC02000000000040E; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2532135\n"); + end + x = 64'hC1F000F000000000; + y = 64'hB80000800001FFFF; + z = 64'h3FC8304279FDE7F0; + ans = 64'h3FC8304279FDE7F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2532749\n"); + end + x = 64'h4000000080001000; + y = 64'h4000000000000001; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2533363\n"); + end + x = 64'h7FE0000000000000; + y = 64'h4095FFFFFFFFFFFF; + z = 64'h43DDFFFFFFF7FFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2533977\n"); + end + x = 64'h47E00000000083FF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hA81F7FFFFFFFFFFE; + ans = 64'h48000000000083FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2534591\n"); + end + x = 64'h7FE0000000000000; + y = 64'hBFAC9D7B95393F9A; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hFF9C9D7B95393F9A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2535205\n"); + end + x = 64'h47FD53F8480209BD; + y = 64'h5B10000000003FE0; + z = 64'h3818000000000006; + ans = 64'h631D53F848027ED2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2535819\n"); + end + x = 64'h7FE0000000000000; + y = 64'h4010000000000001; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2536433\n"); + end + x = 64'h402000040003FFFE; + y = 64'h3FFA36685A1C57E1; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h402A366EE7BCFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2537047\n"); + end + x = 64'h7FE0000000000000; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h41DFFDFFFFFFFFFC; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2537661\n"); + end + x = 64'h41E7FFFFFFFFFBFF; + y = 64'h4003FFFEFFFFFFFE; + z = 64'h44C0000003BFFFFF; + ans = 64'h44C0000003C000EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2538275\n"); + end + x = 64'hC00FFFFFFFDFFFF0; + y = 64'h4340000000000000; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2538889\n"); + end + x = 64'h7FE0000000000000; + y = 64'h3C60DB966C536079; + z = 64'hC05FFFFFE8000000; + ans = 64'h7C50DB966C536079; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2539503\n"); + end + x = 64'hC5F00001007FFFFE; + y = 64'h4340000000000001; + z = 64'hBFF56B74EF72E498; + ans = 64'hC9400001007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2540117\n"); + end + x = 64'h7FE0000000000000; + y = 64'h43D00000081FFFFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2540731\n"); + end + x = 64'h48BFFFEFFFDFFFFF; + y = 64'hC0EFFFFFFFF9FFFF; + z = 64'hC3E7DFFFFFFFFFFF; + ans = 64'hC9BFFFEFFFDA0001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2541345\n"); + end + x = 64'h7FE0000000000000; + y = 64'h7FE0000000000000; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2541959\n"); + end + x = 64'h3FE0002000000040; + y = 64'h3FEC0ABDA0188AA0; + z = 64'h3CA0000000000000; + ans = 64'h3FDC0AF5B593CB43; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2542573\n"); + end + x = 64'h7FE0000000000000; + y = 64'h7FE0000000000001; + z = 64'hC3EA2ECD4C6AACA2; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2543187\n"); + end + x = 64'h402FFFFFFFFFBF80; + y = 64'h3FFFFFF00FFFFFFF; + z = 64'h403462A60FA855C0; + ans = 64'h404A314B0FD40AA0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2543801\n"); + end + x = 64'h47E0000800001FFE; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h7FE0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2544415\n"); + end + x = 64'h7FE0000000000000; + y = 64'h41BFFDFFFFFFBFFF; + z = 64'h3FF0040000800000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2545029\n"); + end + x = 64'h43F84175528AF1B9; + y = 64'h7FF0000000000000; + z = 64'h00134D6087A330D2; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2545643\n"); + end + x = 64'h7FE0000000000000; + y = 64'hB7EF4D5D25A022C2; + z = 64'hBFF0000000000000; + ans = 64'hF7DF4D5D25A022C2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2546257\n"); + end + x = 64'hBB0FB893E0DECB72; + y = 64'hC1CFFFF7FFBFFFFF; + z = 64'hC03FFC0000003FFF; + ans = 64'hC03FFC0000003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2546871\n"); + end + x = 64'h7FE0000000000000; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h4000000000000000; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -63769,12 +195040,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2730983\n"); + $fwrite(fp,"2547485\n"); end - x = 64'hA13FFFFFFFBFFFF6; - y = 64'h3FE0000000000001; - z = 64'hC3C0100FFFFFFFFF; - ans = 64'hC3C0100FFFFFFFFF; + x = 64'h476020000FFFFFFF; + y = 64'h37E01FFFFFBFFFFE; + z = 64'h0010000000000001; + ans = 64'h3F5040400FDF7FFD; rn = 1; rz = 0; rm = 0; @@ -63816,480 +195087,809 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2732997\n"); + $fwrite(fp,"2548099\n"); end - x = 64'hC0F00000001F7FFF; - y = 64'hB7F4201E7C0834E7; - z = 64'h450F8003FFFFFFFE; - ans = 64'h450F8003FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2735011\n"); - end - x = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2737025\n"); - end - x = 64'h40318E6058B65A02; - y = 64'h4000000000000000; - z = 64'hB9B00000000FFDFF; - ans = 64'h40418E6058B65A02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2739039\n"); - end - x = 64'h41E007FFFF800000; - y = 64'h4EDFFEFBFFFFFFFF; - z = 64'h3F6000002001FFFF; - ans = 64'h50D0077DBE80040F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2741053\n"); - end - x = 64'h7FEFFFFFFFFFFFFE; - y = 64'h4010000000000001; - z = 64'hBFF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2743067\n"); - end - x = 64'h480FF83FFFFFFFFE; - y = 64'h4340000000000000; - z = 64'hC1CFFFFFFFFFFFC1; - ans = 64'h4B5FF83FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2745081\n"); - end - x = 64'hC7EFFFFDFFFEFFFF; - y = 64'hBE6FFFFFFFBFFF7E; - z = 64'hB81000000037FFFE; - ans = 64'h466FFFFDFFBEFF81; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2747095\n"); - end - x = 64'h7FEFFFFFFFFFFFFE; - y = 64'h7FE0000000000001; - z = 64'h4340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2749109\n"); - end - x = 64'h4220000000808000; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hC80AECD2C45760C7; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2751123\n"); - end - x = 64'h37E000000001FFFF; - y = 64'h434001000007FFFF; - z = 64'h38100007FFE00000; - ans = 64'h3B300100000A0022; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2753137\n"); - end - x = 64'h7FEFFFFFFFFFFFFE; + x = 64'h7FE0000000000000; y = 64'h8000000000000000; + z = 64'hD011287150AEFD43; + ans = 64'hD011287150AEFD43; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2548713\n"); + end + x = 64'h4D64A98A03D930E9; + y = 64'hBFEFFFF000003FFF; + z = 64'hC03E000008000000; + ans = 64'hCD64A97FAF14584F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2549327\n"); + end + x = 64'hB140008000000FFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2549941\n"); + end + x = 64'h7FE0000000000000; + y = 64'hC3500000040003FF; + z = 64'hA54FFFFFFFFF801F; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2550555\n"); + end + x = 64'h403FFFFEFFFFFDFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hC3EFFFFFF7FFEFFF; + ans = 64'hC3EFFFFFF7FFEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2551169\n"); + end + x = 64'h7FE0000000000000; + y = 64'hC1D0020000000003; + z = 64'hBFE0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2551783\n"); + end + x = 64'h207FFFFFFFFFFF07; + y = 64'hBFE000000000401F; + z = 64'hB7E0040FFFFFFFFF; + ans = 64'hB7E0040FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2552397\n"); + end + x = 64'h7FE0000000000000; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'hC007FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2553011\n"); + end + x = 64'hBFB7539AB7055255; + y = 64'hB7F07FFFFFFC0000; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h37B80E378CB7A801; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2553625\n"); + end + x = 64'h7FE0000000000000; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h41CFFFE0007FFFFF; + ans = 64'h41CFFFDFFE7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2554239\n"); + end + x = 64'hB0BFFFFFF8000000; + y = 64'hC039090F6427704A; + z = 64'h37FCC8AD640425EC; + ans = 64'h37FCC8AD640425EC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2554853\n"); + end + x = 64'hC1FA7A8D6AE07DA3; + y = 64'hBCA0000000000001; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h402000001A7A8D6A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2555467\n"); + end + x = 64'h7FE0000000000000; + y = 64'hBFAFFFFFFFF80001; + z = 64'hA370000000008006; + ans = 64'hFF9FFFFFFFF80001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2556081\n"); + end + x = 64'hBF141E8D0C4FEF1D; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h43FFFE00000001FF; + ans = 64'h43FFFE00000001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2556695\n"); + end + x = 64'h7FE0000000000000; + y = 64'h4E401FFFFFFFFBFE; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2557309\n"); + end + x = 64'h3FE2E1C5E52BB3A1; + y = 64'hC3F0004100000000; + z = 64'h402FFFFE0003FFFF; + ans = 64'hC3E2E2129A5FA6A3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2557923\n"); + end + x = 64'h7FE0000000000000; + y = 64'hBFD0000000000001; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'hFFC0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2558537\n"); + end + x = 64'h3895AD9CB6F014AE; + y = 64'h48E00000003FF7FF; z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; @@ -64333,12 +195933,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2755151\n"); + $fwrite(fp,"2559151\n"); end - x = 64'h3F5FFF80003FFFFF; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hBFCFFFFBFFFFFFBF; - ans = 64'hBFCFFFFBFFFFFFBF; + x = 64'h7FE0000000000000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h43DBFDFA22D31748; + ans = 64'hFFCFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -64380,12 +195980,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2757165\n"); + $fwrite(fp,"2559765\n"); end - x = 64'h40EFFFFF77FFFFFE; - y = 64'hB7E00C0000000000; - z = 64'hBFF705F4048A86F0; - ans = 64'hBFF705F4048A86F0; + x = 64'hCB5FFF000FFFFFFE; + y = 64'hBEBBFE0000000000; + z = 64'hFFD397BE63CB741C; + ans = 64'hFFD397BE63CB741C; rn = 1; rz = 0; rm = 0; @@ -64427,153 +196027,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2759179\n"); + $fwrite(fp,"2560379\n"); end - x = 64'h7FEFFFFFFFFFFFFE; - y = 64'hBCA0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hFC9FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2761193\n"); - end - x = 64'h7FF0000FFFEFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h37F00000000040FE; - ans = 64'h7FF8000FFFEFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2763207\n"); - end - x = 64'hB6C00000FFFFE000; - y = 64'h408FFEFFFFFFC000; - z = 64'h3F2E0000001FFFFF; - ans = 64'h3F2E0000001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2765221\n"); - end - x = 64'h7FEFFFFFFFFFFFFE; + x = 64'hB810002002000000; y = 64'hBFE0000000000000; - z = 64'h3FF0000000000001; - ans = 64'hFFDFFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -64615,12 +196074,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2767235\n"); + $fwrite(fp,"2560993\n"); end - x = 64'h3DC03FFFFFFF7FFE; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hC3FFFF7FFFFFFF00; - ans = 64'hC3FFFF7FFFFFFF00; + x = 64'h7FE0000000000000; + y = 64'h40000000000017FF; + z = 64'h3FE8000000000080; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -64662,12 +196121,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2769249\n"); + $fwrite(fp,"2561607\n"); end - x = 64'h43FFFFFC0000FFFE; - y = 64'hBFFB2CF1E73D8A09; - z = 64'hBFD4AF8A8F842F1A; - ans = 64'hC40B2CEE81A02687; + x = 64'h407FFFFF00003FFF; + y = 64'hBFE0000000000001; + z = 64'h247FFFEFFFFFFFFB; + ans = 64'hC06FFFFF00004001; rn = 1; rz = 0; rm = 0; @@ -64709,11 +196168,528 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2771263\n"); + $fwrite(fp,"2562221\n"); end - x = 64'h7FEFFFFFFFFFFFFE; + x = 64'h7FE0000000000000; + y = 64'h434FFFFFFFF8007F; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2562835\n"); + end + x = 64'h3CAFFFDFFFFFFFF8; + y = 64'h4036FF793EA8AA59; + z = 64'hC3F615879A14A987; + ans = 64'hC3F615879A14A987; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2563449\n"); + end + x = 64'h7FE0000000000000; + y = 64'hBFF0000000000000; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2564063\n"); + end + x = 64'hA6F004000000001F; + y = 64'h3800000000000FF7; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2564677\n"); + end + x = 64'h7FE0000000000000; + y = 64'hBFF0000000000001; + z = 64'hBFCFFFFFFFFFFC07; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2565291\n"); + end + x = 64'hC04000001FF7FFFF; + y = 64'hFD2FFFBFFFF7FFFF; + z = 64'h40100000000007EF; + ans = 64'h7D7FFFC03FE7801D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2565905\n"); + end + x = 64'h3E5EFFFFFFDFFFFF; y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hC340000000000000; + z = 64'h4000000000000000; + ans = 64'h3FFFFFFFF0800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2566519\n"); + end + x = 64'h7FE0000000000000; + y = 64'hBFE000040000000E; + z = 64'hA21FFE00000FFFFF; + ans = 64'hFFD000040000000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2567133\n"); + end + x = 64'h3F00200000000000; + y = 64'hC000000000000000; + z = 64'h3F7FFFEFFFF80000; + ans = 64'h3F7FBF6FFFF80000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2567747\n"); + end + x = 64'h7FE0000000000000; + y = 64'h7FE3F4CB8A40190A; + z = 64'hBCA0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2568361\n"); + end + x = 64'h3CA007EFFFFFFFFE; + y = 64'h79400001FFFDFFFF; + z = 64'h3F300000008007FE; + ans = 64'h75F007F200FBFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2568975\n"); + end + x = 64'h7FE0000000000000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h3FD0000000000000; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -64756,12 +196732,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2773277\n"); + $fwrite(fp,"2569589\n"); end - x = 64'hC03FFFFFFFFFFBEF; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'hC07FFFFE02000000; - ans = 64'hC077FFFE02000104; + x = 64'h3FEFFFFFFDBFFFFF; + y = 64'h3FE0808805F24554; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; rn = 1; rz = 0; rm = 0; @@ -64803,12 +196779,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2775291\n"); + $fwrite(fp,"2570203\n"); end - x = 64'hBCA0001008000000; - y = 64'h41C0000000000FDF; - z = 64'h3FEAC3E63849250D; - ans = 64'h3FEAC3E6184904FD; + x = 64'h7FE0000000000000; + y = 64'hC010000000000000; + z = 64'hC1F00FFFFDFFFFFF; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -64850,12 +196826,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2777305\n"); + $fwrite(fp,"2570817\n"); end - x = 64'h7FEFFFFFFFFFFFFE; + x = 64'h3FFFFFFF7FFFE000; + y = 64'hC8003FFFFFFFFFFB; + z = 64'hEB6FFFFFFFFFF3FF; + ans = 64'hEB6FFFFFFFFFF3FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2571431\n"); + end + x = 64'h45200001FF7FFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'hC5500001FF7FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2572045\n"); + end + x = 64'h7FE0000000000000; + y = 64'h7FEFFFFFEEFFFFFF; + z = 64'hBF3FFFFFDFFFFDFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2572659\n"); + end + x = 64'h000FFFDFFFFFFF00; y = 64'hC01FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC3FA99119A2842A6; + ans = 64'hC3FA99119A2842A6; rn = 1; rz = 0; rm = 0; @@ -64897,105 +197014,105 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2779319\n"); + $fwrite(fp,"2573273\n"); end - x = 64'h3F0FF7FFFFFFC000; + x = 64'h7FE0000000000000; + y = 64'h3FC0000000080003; + z = 64'h8010000000000001; + ans = 64'h7FB0000000080003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2573887\n"); + end + x = 64'hBF70017FFFFFFFFF; + y = 64'h4C9F9B8BEED274A1; + z = 64'h381FF80007FFFFFF; + ans = 64'hCC1F9E8283F0D85A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2574501\n"); + end + x = 64'h7FE0000000000000; y = 64'hC34FFFFFFFFFFFFF; - z = 64'h3FEEFFFFFFFF7FFF; - ans = 64'hC26FF7FFFFFFA0FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2781333\n"); - end - x = 64'hC01FFFFFFFFFEFBF; - y = 64'h801000000010FFFF; - z = 64'hC3D0003FFFFFFF80; - ans = 64'hC3D0003FFFFFFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2783347\n"); - end - x = 64'h7FEFFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3CA0000000000001; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -65038,11 +197155,387 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2785361\n"); + $fwrite(fp,"2575115\n"); end - x = 64'h3FC3F637647C8A8C; + x = 64'hFFDFFF7FFF7FFFFF; + y = 64'h40FFFFFFFFFFFFBE; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2575729\n"); + end + x = 64'h7FE0000000000000; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hCE2FFFFF00001FFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2576343\n"); + end + x = 64'h38010000FFFFFFFF; + y = 64'h2B2FBFFFFFFC0000; + z = 64'hC3F000000000FE00; + ans = 64'hC3F000000000FE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2576957\n"); + end + x = 64'hB84FFFE040000000; + y = 64'hFFE0000000000001; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h783FFFE040000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2577571\n"); + end + x = 64'h7FE0000000000000; + y = 64'h4343A027130C87B4; + z = 64'h80000000000001DF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2578185\n"); + end + x = 64'h47FFFFFFDFFFFFE0; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h00004003FFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2578799\n"); + end + x = 64'h7FE0000000000000; + y = 64'hBFDCD7EBDC5A0408; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'hFFCCD7EBDC5A0408; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2579413\n"); + end + x = 64'hFFEFFFFFFFFE0400; + y = 64'hBF2000FBFFFFFFFF; + z = 64'h3E8401FFFFFFFFFF; + ans = 64'h7F2000FBFFFF01EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2580027\n"); + end + x = 64'h7FE0000000000000; y = 64'hFFF0000000000001; - z = 64'hBF1FF0003FFFFFFE; + z = 64'h001FFFFFFFFFFFFF; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -65085,12 +197578,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2787375\n"); + $fwrite(fp,"2580641\n"); end - x = 64'hBFF9BABB71F7F8B0; - y = 64'hB80FFFFFDFFFFFEE; - z = 64'hBB7000000000003E; - ans = 64'hBB7000000000003E; + x = 64'hC08FFFFFFFFF7FDE; + y = 64'h43D09DCF5E6E7F53; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC4709DCF5E6E3CCA; rn = 1; rz = 0; rm = 0; @@ -65132,1562 +197625,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2789389\n"); + $fwrite(fp,"2581255\n"); end - x = 64'h7FF0000000000000; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2791403\n"); - end - x = 64'hBFC3FC9335D22F67; - y = 64'h0010000000000001; - z = 64'h41CFFFC000FFFFFF; - ans = 64'h41CFFFC000FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2793417\n"); - end - x = 64'h3F1FFFFFE0000004; - y = 64'h426CEDD14CA226B4; - z = 64'h41E00007FFFF7FFF; - ans = 64'h41E0E776897D22AA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2795431\n"); - end - x = 64'h7FF0000000000000; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2797445\n"); - end - x = 64'hB81D83911AC173B1; - y = 64'h3FD0000000000000; - z = 64'h800FFFFFFDFDFFFF; - ans = 64'hB7FD83911AC173B1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2799459\n"); - end - x = 64'hC1DC0000000FFFFF; - y = 64'hBB9FFBFFFFFDFFFF; - z = 64'h802992FB76E672FC; - ans = 64'h3D8BFC80000E3DFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2801473\n"); - end - x = 64'h7FF0000000000000; - y = 64'h3FE0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2803487\n"); - end - x = 64'hC08FFFFFFFFE001E; - y = 64'h3FF0000000000000; - z = 64'hC070220000000000; - ans = 64'hC094087FFFFF000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2805501\n"); - end - x = 64'hC34003FFFFFFFDFE; - y = 64'h43C0000000200000; - z = 64'h961FFFFFFFFFFFC3; - ans = 64'hC7100400002005FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2807515\n"); - end - x = 64'h7FF0000000000000; - y = 64'h4000000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2809529\n"); - end - x = 64'h8003D79E3B794CCF; - y = 64'h4010000000000000; - z = 64'h3FD008000FFFFFFF; - ans = 64'h3FD008000FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2811543\n"); - end - x = 64'h3F200005FFFFFFFF; - y = 64'h801FF00004000000; - z = 64'hC3D002000003FFFF; - ans = 64'hC3D002000003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2813557\n"); - end - x = 64'h7FF0000000000000; - y = 64'h4340000000000001; - z = 64'h3FF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2815571\n"); - end - x = 64'hBFB58386CB4FD276; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hC72000200003FFFE; - ans = 64'hC72000200003FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2817585\n"); - end - x = 64'h4D4FFFFFFFD7FFFF; - y = 64'hBFF2228BAA70FAE0; - z = 64'h2F00010000000001; - ans = 64'hCD52228BAA5A4FB1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2819599\n"); - end - x = 64'h7FF0000000000000; - y = 64'h7FF0000000000000; - z = 64'hC340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2821613\n"); - end - x = 64'hB7E92B1594C31403; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hB81FFFFFFFFFF807; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2823627\n"); - end - x = 64'h47EFE00003FFFFFF; - y = 64'hC36E9EBBDD2B9332; - z = 64'h5FE200000001FFFF; - ans = 64'h5FE200000001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2825641\n"); - end - x = 64'h7FF0000000000000; - y = 64'h8010000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2827655\n"); - end - x = 64'h4060000000080FFE; - y = 64'h801FFFFFFFFFFFFE; - z = 64'h47FFFC000FFFFFFF; - ans = 64'h47FFFC000FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2829669\n"); - end - x = 64'h3FC765C9DCA95998; - y = 64'h41EFFFF7FFFFFDFF; - z = 64'h758FFDFF80000000; - ans = 64'h758FFDFF80000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2831683\n"); - end - x = 64'h7FF0000000000000; - y = 64'hBFD0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2833697\n"); - end - x = 64'hCD41FFFFFFFE0000; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hB5400FFFFFDFFFFF; - ans = 64'h4D31FFFFFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2835711\n"); - end - x = 64'hC34FFDFFFFFF7FFF; - y = 64'h360FFFFFFFFFFFBE; - z = 64'h3F5FFFFEFFFFFFFC; - ans = 64'h3F5FFFFEFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2837725\n"); - end - x = 64'h7FF0000000000000; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2839739\n"); - end - x = 64'hC3368331494C07F2; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h41D0000007FFFFFF; - ans = 64'h43468331694C0801; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2841753\n"); - end - x = 64'h3FE0000000020002; - y = 64'h3D810001FFFFFFFF; - z = 64'h00107FFFFFFEFFFE; - ans = 64'h3D71000200022001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2843767\n"); - end - x = 64'h7FF0000000000000; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2845781\n"); - end - x = 64'h405001FFFFFFFFBF; - y = 64'hC010000000000001; - z = 64'hBFE01FFFFFFFFFFB; - ans = 64'hC0700A0FFFFFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2847795\n"); - end - x = 64'hB93FFFFFFFAFFFFF; - y = 64'h03375E80771445CC; - z = 64'hC7F0200000080000; - ans = 64'hC7F0200000080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2849809\n"); - end - x = 64'h7FF0000000000000; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2851823\n"); - end - x = 64'hFFDEEFFFFFFFFFFF; - y = 64'hFFE0000000000001; - z = 64'h4010003FBFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2853837\n"); - end - x = 64'h3FCFFFFFFFFBFFFC; - y = 64'h2CCFFFE000002000; - z = 64'hB7F6B5109C9601B2; - ans = 64'hB7F6B5109C9601B2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2855851\n"); - end - x = 64'h7FF0000000000000; + x = 64'h7FE0000000000000; y = 64'hFFFFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; + z = 64'hC00FFFFFFFC0003F; ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -66730,12 +197672,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2857865\n"); + $fwrite(fp,"2581869\n"); end - x = 64'hC3F57089C2360CCF; + x = 64'h3EE03F0000000000; + y = 64'hB818459D897A9352; + z = 64'h3FF0001FF7FFFFFF; + ans = 64'h3FF0001FF7FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2582483\n"); + end + x = 64'hC03FFFFFFFFFF810; + y = 64'h0000000000000000; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2583097\n"); + end + x = 64'h7FE0000000000001; + y = 64'h43CEC1D751CCA01A; + z = 64'h449A27D1BF4384DC; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2583711\n"); + end + x = 64'h48000FFFFFFFFDFF; y = 64'h0000000000000001; - z = 64'hC03FFFF001FFFFFF; - ans = 64'hC03FFFF001FFFFFF; + z = 64'h22DFFFFFF83FFFFF; + ans = 64'h22DFFFFFF83FFFFF; rn = 1; rz = 0; rm = 0; @@ -66777,339 +197860,10 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2859879\n"); + $fwrite(fp,"2584325\n"); end - x = 64'hC3407FFFFFFFFFFA; - y = 64'h3FEFFFFFFFFF007F; - z = 64'hC1CEF00000000000; - ans = 64'hC34080001EEF7C3B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2861893\n"); - end - x = 64'h7FF0000000000001; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2863907\n"); - end - x = 64'hDC207FFFFDFFFFFE; - y = 64'h3CA0000000000000; - z = 64'hBFC02000007FFFFE; - ans = 64'hD8D07FFFFDFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2865921\n"); - end - x = 64'hC03FFFFFFFFFD800; - y = 64'h000FFFFFFFFFFC00; - z = 64'h43DCB39AE49E1855; - ans = 64'h43DCB39AE49E1855; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2867935\n"); - end - x = 64'h7FF0000000000001; - y = 64'h3FD0000000000001; - z = 64'hC340000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2869949\n"); - end - x = 64'hB056EDFAFD7AECD8; - y = 64'h3FE0000000000000; - z = 64'h46FFF80002000000; - ans = 64'h46FFF80002000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2871963\n"); - end - x = 64'hC34FFC00FFFFFFFF; - y = 64'hBEF38655F21F4B0D; - z = 64'h412FF8000000003F; - ans = 64'h425383E9C293B6B4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2873977\n"); - end - x = 64'h7FF0000000000001; - y = 64'h3FF0000000000001; + x = 64'h7FE0000000000001; + y = 64'hB7FC2CB5D458BDC2; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -67153,12 +197907,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2875991\n"); + $fwrite(fp,"2584939\n"); end - x = 64'hC07FFE0001FFFFFF; - y = 64'h4000000000000000; - z = 64'h4210080000007FFE; - ans = 64'h421007FFF0017FFD; + x = 64'hFFEFFFFFFFFF7F7E; + y = 64'hC0F5EDD88E0E7D5D; + z = 64'hBEDDD10872C31AB9; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -67200,12 +197954,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2878005\n"); + $fwrite(fp,"2585553\n"); end - x = 64'hBFDFFFE00FFFFFFF; - y = 64'h3FCCF2165E6EEA40; - z = 64'h3FF0000023FFFFFE; - ans = 64'h3FEC61C118A5CD1C; + x = 64'h7FE0000000000001; + y = 64'h0010000000000000; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h4000000000000001; rn = 1; rz = 0; rm = 0; @@ -67247,12 +198001,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2880019\n"); + $fwrite(fp,"2586167\n"); end - x = 64'h7FF0000000000001; - y = 64'h4010000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; + x = 64'h301AF9D2D5A4BA0D; + y = 64'hC7FFDFFFFFFFFFFC; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; rn = 1; rz = 0; rm = 0; @@ -67294,12 +198048,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2882033\n"); + $fwrite(fp,"2586781\n"); end - x = 64'h40EAFF598CEFFAB8; - y = 64'h401FFFFFFFFFFFFE; - z = 64'hE20FFC0000007FFE; - ans = 64'hE20FFC0000007FFE; + x = 64'h7FE0000000000001; + y = 64'h0010000000000001; + z = 64'hFFD000000003FC00; + ans = 64'hFFD000000003FC00; rn = 1; rz = 0; rm = 0; @@ -67341,12 +198095,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2884047\n"); + $fwrite(fp,"2587395\n"); end - x = 64'hC370000000007FFF; - y = 64'h433BD43E9121C012; - z = 64'hC1C48DB40A6B57F3; - ans = 64'hC6BBD43E91229EB2; + x = 64'h401903F79E80A3D6; + y = 64'h4003A3DBDB0C18E4; + z = 64'hC34002001FFFFFFE; + ans = 64'hC34002001FFFFFF6; rn = 1; rz = 0; rm = 0; @@ -67388,12 +198142,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2886061\n"); + $fwrite(fp,"2588009\n"); end - x = 64'h7FF0000000000001; - y = 64'h7FE0000000000000; - z = 64'hBFF0000000000001; - ans = 64'h7FF8000000000001; + x = 64'h434FFFFFEFFFEFFE; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; rn = 1; rz = 0; rm = 0; @@ -67435,11 +198189,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2888075\n"); + $fwrite(fp,"2588623\n"); end - x = 64'hC03F7FFFFFFFFFFD; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hC34FFFFFF9FFFFFE; + x = 64'h7FE0000000000001; + y = 64'hC1C7559F1A1AD753; + z = 64'hBBE000000FFFFF00; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -67482,12 +198236,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2890089\n"); + $fwrite(fp,"2589237\n"); end - x = 64'h40207FDFFFFFFFFF; - y = 64'h47D64227C844223E; - z = 64'hC03F7FFFFFFFFFFE; - ans = 64'h4806F40C8236B2C6; + x = 64'h7FE0FFFFFFFF7FFF; + y = 64'h3CA0000000000000; + z = 64'h43CF7D67F6C113D7; + ans = 64'h7C90FFFFFFFF7FFF; rn = 1; rz = 0; rm = 0; @@ -67529,11 +198283,1985 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2892103\n"); + $fwrite(fp,"2589851\n"); end - x = 64'h7FF0000000000001; - y = 64'h8000000000000000; - z = 64'h4340000000000000; + x = 64'h7FE0000000000001; + y = 64'h3EFFFFFF80100000; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2590465\n"); + end + x = 64'h3DF88E3F2C57962B; + y = 64'h41EFFE00007FFFFF; + z = 64'hFFF00000200001FF; + ans = 64'hFFF80000200001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2591079\n"); + end + x = 64'h7FE0000000000001; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h0000000000000000; + ans = 64'h7CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2591693\n"); + end + x = 64'h4A00000003FFE000; + y = 64'h43E5972BA17D5A64; + z = 64'hC000000000000001; + ans = 64'h4DF5972BA6E2FA1E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2592307\n"); + end + x = 64'h7FE0000000000001; + y = 64'h3FD0000000000000; + z = 64'hBFE28124FEC4E8F9; + ans = 64'h7FC0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2592921\n"); + end + x = 64'h5C700006FFFFFFFF; + y = 64'hC3C88EB3A3479B67; + z = 64'h8010000000001FDE; + ans = 64'hE0488EBE61B632D5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2593535\n"); + end + x = 64'hC3F4D646CE330C0B; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3CA0000000000001; + ans = 64'hC3E4D646CE330C0A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2594149\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC1FFFFFFFFFF0000; + z = 64'hCEC03FFFFFFF7FFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2594763\n"); + end + x = 64'h47EFF07FFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3A3FFFFFFFFF9FFE; + ans = 64'h47DFF07FFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2595377\n"); + end + x = 64'h7FE0000000000001; + y = 64'h3D7FC86542A6B145; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000001FC9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2595991\n"); + end + x = 64'h9B4FDFFFFFFFFFFB; + y = 64'h41FFFFFFFEEFFFFF; + z = 64'h4FEFFF0000000080; + ans = 64'h4FEFFF0000000080; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2596605\n"); + end + x = 64'h7FE0000000000001; + y = 64'h3FE0000000000001; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2597219\n"); + end + x = 64'h78BFFFFFBFFFFDFF; + y = 64'h002001FBFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2597833\n"); + end + x = 64'h7FE0000000000001; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h3CA0001FFFFFFFBF; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2598447\n"); + end + x = 64'h3800000007FFFFFE; + y = 64'hB7FFFFFFF80003FF; + z = 64'h43D58662EFB06D82; + ans = 64'h43D58662EFB06D82; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2599061\n"); + end + x = 64'hC0FEFFFFDFFFFFFF; + y = 64'h3FF0000000000001; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hC0FEFFFFE0000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2599675\n"); + end + x = 64'h7FE0000000000001; + y = 64'hE54FE00FFFFFFFFF; + z = 64'hC1E721896DA410CA; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2600289\n"); + end + x = 64'h800000000E000000; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h034FFFF80FFFFFFE; + ans = 64'h034FFFF80FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2600903\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC03F800007FFFFFF; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2601517\n"); + end + x = 64'hC3DFFFFFFFEFEFFF; + y = 64'h380CD67FF96631CD; + z = 64'hBFF001FFFFFFDFFF; + ans = 64'hBFF001FFFFFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2602131\n"); + end + x = 64'h7FE0000000000001; + y = 64'h4000000000000000; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'h7CB8000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2602745\n"); + end + x = 64'hBFCFF80000FFFFFE; + y = 64'h434FFFFD7FFFFFFF; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hC32FF7FD819FFFEB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2603359\n"); + end + x = 64'h7FE0000000000001; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h59303FFFF7FFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2603973\n"); + end + x = 64'hC37FFFFEFFFFFFFF; + y = 64'h40C00000000BFFFE; + z = 64'h47FFFFFF7FFFFFF7; + ans = 64'h47FFFFFF7FFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2604587\n"); + end + x = 64'h19AC61120CE93DEC; + y = 64'h4010000000000000; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h19CC61120CE93DEC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2605201\n"); + end + x = 64'h7FE0000000000001; + y = 64'hBFC20000000001FE; + z = 64'h41DFFFC00007FFFF; + ans = 64'hFFB20000000001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2605815\n"); + end + x = 64'hBFE000007FFFFF00; + y = 64'h4010000000000001; + z = 64'h7FD0000000002000; + ans = 64'h7FD0000000002000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2606429\n"); + end + x = 64'h7FE0000000000001; + y = 64'h7FF00003FFFFFFFD; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h7FF80003FFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2607043\n"); + end + x = 64'h41EFFFFFEFFFFFC0; + y = 64'hBF0FFFF00003FFFE; + z = 64'h3C94001FFFFFFFFE; + ans = 64'hC10FFFEFF00407BE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2607657\n"); + end + x = 64'h7FE0000000000001; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2608271\n"); + end + x = 64'hC010040000FFFFFF; + y = 64'hC0D1FFFFFFFFC000; + z = 64'hBFE0000000000000; + ans = 64'h40F20478011FBFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2608885\n"); + end + x = 64'h7FE0000000000001; + y = 64'h4340000000000001; + z = 64'h400F00001FFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2609499\n"); + end + x = 64'h3CAFFFFFF7FF0000; + y = 64'hC0A069D658AB80BD; + z = 64'h400FC0000000003F; + ans = 64'h400FBFFFFFFFFC25; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2610113\n"); + end + x = 64'h38000FFEFFFFFFFE; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h0000000000000000; + ans = 64'h3B600FFEFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2610727\n"); + end + x = 64'h7FE0000000000001; + y = 64'hBEAFFFF0000001FF; + z = 64'h3500000000000FF8; + ans = 64'hFE9FFFF000000201; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2611341\n"); + end + x = 64'hC06FFFF800000010; + y = 64'h7FE0000000000000; + z = 64'hC1DF1F5FFFC2803A; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2611955\n"); + end + x = 64'h7FE0000000000001; + y = 64'h400020001FFFFFFF; + z = 64'h4010000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2612569\n"); + end + x = 64'hAE56D8F6C524E8AD; + y = 64'hC030000060000000; + z = 64'h4340000000000002; + ans = 64'h4340000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2613183\n"); + end + x = 64'h7FE0000000000001; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2613797\n"); + end + x = 64'hC3E54C4A34BFA6E4; + y = 64'hBFC00000FFFFFBFF; + z = 64'hBFD0000000000001; + ans = 64'h43B54C4B898444DC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2614411\n"); + end + x = 64'h7FE0000000000001; + y = 64'h7FF0000000000000; + z = 64'h002FFF800001FFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2615025\n"); + end + x = 64'hC0103FF800000000; + y = 64'h434007FFFFFFEFFF; + z = 64'hBC70000FFFFFFFF7; + ans = 64'hC3604817FBFFEFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2615639\n"); + end + x = 64'hBF2175E0432D769D; + y = 64'h7FF0000000000001; + z = 64'hFFF0000000000001; ans = 64'h7FF8000000000001; rn = 1; rz = 0; @@ -67576,12 +200304,5558 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2894117\n"); + $fwrite(fp,"2616253\n"); end - x = 64'hC010077FFFFFFFFE; + x = 64'h7FE0000000000001; + y = 64'hB8040179B06430AA; + z = 64'h43E0000000800400; + ans = 64'hF7F40179B06430AB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2616867\n"); + end + x = 64'h401EFFFFFFFFFFF7; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC00FFFFBFFFBFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2617481\n"); + end + x = 64'h7FE0000000000001; + y = 64'h80200004FFFFFFFF; + z = 64'h4000000000000001; + ans = 64'hC0000009FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2618095\n"); + end + x = 64'h37EFFF7FF7FFFFFF; + y = 64'h3EB87964ABACA6C6; + z = 64'hC014000000080000; + ans = 64'hC014000000080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2618709\n"); + end + x = 64'h7FE0000000000001; + y = 64'h8000000000000001; + z = 64'hC010000000000001; + ans = 64'hC010000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2619323\n"); + end + x = 64'h37FFFFDFFFFE0000; + y = 64'h47F23D7F24A38646; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h40023D6CE7233DCA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2619937\n"); + end + x = 64'h7FE0000000000001; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hBED0003F7FFFFFFE; + ans = 64'hC00000020007EFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2620551\n"); + end + x = 64'h215F7FFFBFFFFFFE; + y = 64'h3960000100000001; + z = 64'hC7EFFFFBFEFFFFFF; + ans = 64'hC7EFFFFBFEFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2621165\n"); + end + x = 64'hC071FFFFFF7FFFFE; + y = 64'h8010000000000000; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2621779\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC0200000FDFFFFFF; + z = 64'h4053FDFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2622393\n"); + end + x = 64'hC7FFFFFFE0000010; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hBF2F800000000001; + ans = 64'hBF2F800000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2623007\n"); + end + x = 64'h7FE0000000000001; + y = 64'h801000000001FEFF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'hBDCFF00800000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2623621\n"); + end + x = 64'h3800FFFFFFFFF800; + y = 64'h000FBC0000000000; + z = 64'h40DFEFFFFFFFFFF0; + ans = 64'h40DFEFFFFFFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2624235\n"); + end + x = 64'h7FE0000000000001; + y = 64'hBCA0000000000000; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hFC90000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2624849\n"); + end + x = 64'h31BFFFFFE003FFFF; + y = 64'h41EAFA4764C7E465; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h33BAFA4749D0FC48; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2625463\n"); + end + x = 64'h7FE0000000000001; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h7FEFFFFFDFFFFFFC; + ans = 64'h7FEFFFFFDFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2626077\n"); + end + x = 64'hFFFFFFFDFFFFFFF7; + y = 64'hC02FF00FFFFFFFFF; + z = 64'h3FBFFFFFBFFDFFFF; + ans = 64'hFFFFFFFDFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2626691\n"); + end + x = 64'hBFAFF7FFFFFE0000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2627305\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC02001FFFFFFFFFE; + z = 64'h3810000000000DFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2627919\n"); + end + x = 64'h001AE1C1BB5B4FDA; + y = 64'hBFD0000000000001; + z = 64'hC17FFFFFFFFFFFCF; + ans = 64'hC17FFFFFFFFFFFCF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2628533\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC24E00000000001F; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2629147\n"); + end + x = 64'h30E1539D6F604313; + y = 64'h415427C6462AF0E6; + z = 64'h4038BBB7881BC9D8; + ans = 64'h4038BBB7881BC9D8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2629761\n"); + end + x = 64'h7FE0000000000001; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hFFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2630375\n"); + end + x = 64'h37EFFFFFFFFDFF7E; + y = 64'hBFAFFFFFFFFFD000; + z = 64'h8010000000000000; + ans = 64'hB7AFFFFFFFFDCF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2630989\n"); + end + x = 64'h7FE0000000000001; + y = 64'hBFE0000000000001; + z = 64'h40332E5BBB9E9819; + ans = 64'hFFD0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2631603\n"); + end + x = 64'h396E5358D2C85AD4; + y = 64'hBFDFEFFFFFFFFFFF; + z = 64'hBFDFC03FFFFFFFFE; + ans = 64'hBFDFC03FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2632217\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2632831\n"); + end + x = 64'h7FE0000000000001; + y = 64'hF4500000007FFF7E; + z = 64'h380FFFF800100000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2633445\n"); + end + x = 64'h40340001FFFFFFFE; + y = 64'hBFF0000000000000; + z = 64'hC1D0080000001FFF; + ans = 64'hC1D008000500207F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2634059\n"); + end + x = 64'h7FE0000000000001; + y = 64'hFFE19967615D1CE2; + z = 64'h3FE0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2634673\n"); + end + x = 64'hC000000002000100; + y = 64'hB7F0002000000000; + z = 64'h402002000000000F; + ans = 64'h402002000000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2635287\n"); + end + x = 64'h7FE0000000000001; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hBFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2635901\n"); + end + x = 64'hD240007FFFFEFFFF; + y = 64'hBFCFFFEFFFF80000; + z = 64'h8000000000000001; + ans = 64'h52200077FFBAFFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2636515\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC000000000000000; + z = 64'h08D127F5978046FD; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2637129\n"); + end + x = 64'hBCE00005FFFFFFFF; + y = 64'h462000003FFFFFFE; + z = 64'hEFF00020001FFFFF; + ans = 64'hEFF00020001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2637743\n"); + end + x = 64'h40236D3BE6BA89EE; + y = 64'hC000000000000001; + z = 64'hC010000000000001; + ans = 64'hC0376D3BE6BA89EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2638357\n"); + end + x = 64'h7FE0000000000001; + y = 64'h37FFFF7FF7FFFFFE; + z = 64'h41F0B0E6E43095BE; + ans = 64'h77EFFF7FF8000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2638971\n"); + end + x = 64'h41F000000FFF7FFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h3FE000100000003E; + ans = 64'hC21000000FFD7FFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2639585\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC1F91E2D92C9A9B5; + z = 64'h3FD0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2640199\n"); + end + x = 64'hC5D0000000880000; + y = 64'h428FFFFFFBFFFDFE; + z = 64'h3F60FFFFFFFFFDFF; + ans = 64'hC86FFFFFFD0FFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2640813\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC010000000000001; + z = 64'hBFE0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2641427\n"); + end + x = 64'hBFDFA132CC5B63C1; + y = 64'h402039FAE3724F00; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2642041\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hA84EFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2642655\n"); + end + x = 64'hBFBFFFDFDFFFFFFE; + y = 64'h8010047FFFFFFFFF; + z = 64'h7FFFFFFFFFFBFFF0; + ans = 64'h7FFFFFFFFFFBFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2643269\n"); + end + x = 64'hC800000020000000; + y = 64'hC340000000000000; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'h4B50000020000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2643883\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC01FFFEFFFFFFF7E; + z = 64'h400FFFF800000080; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2644497\n"); + end + x = 64'hFFEFFFDFFFFFFFC0; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hB7FFFF0000200000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2645111\n"); + end + x = 64'h7FE0000000000001; + y = 64'hC06003BFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2645725\n"); + end + x = 64'h37EB6092B4D1A495; + y = 64'h43600FFFFFFFFF7F; + z = 64'h4024003FFFFFFFFE; + ans = 64'h4024003FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2646339\n"); + end + x = 64'h7FE0000000000001; + y = 64'hFFE0000000000000; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2646953\n"); + end + x = 64'h555E597CBADF25DC; + y = 64'hBFB0000002FFFFFE; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2647567\n"); + end + x = 64'h7FE0000000000001; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h000DC2A2A032E095; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2648181\n"); + end + x = 64'h0BB273916840FDDD; + y = 64'hBFD07FFFFFFFFF7E; + z = 64'h37E0020000800000; + ans = 64'h37E0020000800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2648795\n"); + end + x = 64'h801179AC2F89FF18; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'h4002F3585F13FE2F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2649409\n"); + end + x = 64'h7FE0000000000001; + y = 64'h3FFFFFDFFFFFDFFE; + z = 64'h401F80000000001F; + ans = 64'h7FEFFFDFFFFFE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2650023\n"); + end + x = 64'h3CAAF64D41610A74; + y = 64'hFFF0000000000001; + z = 64'hBF900000007FEFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2650637\n"); + end + x = 64'h7FE0000000000001; + y = 64'h401512D5D6AFD92E; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2651251\n"); + end + x = 64'hC024007FFFFFFFFF; + y = 64'h3E4001000000003E; + z = 64'hC1DFFFFF00010000; + ans = 64'hC1DFFFFF00010000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2651865\n"); + end + x = 64'h7FE0000000000001; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2652479\n"); + end + x = 64'h3810001000000002; + y = 64'hFFDFFFF0000001FF; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2653093\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h0000000000000001; + z = 64'h37FFFFFF7FFFFEFF; + ans = 64'h3CCFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2653707\n"); + end + x = 64'h3CA0000000400040; + y = 64'h000BFFFFFFFBFFFE; + z = 64'h4260000002000000; + ans = 64'h4260000002000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2654321\n"); + end + x = 64'hC1EA26D0FBE678F4; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hBFF0000000000000; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2654935\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC3EFF69E32A24625; + z = 64'hBF88000800000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2655549\n"); + end + x = 64'hC800000003F7FFFF; + y = 64'h0010000000000000; + z = 64'h47F92CC74CE08C7C; + ans = 64'h47F92CC74CE08C7C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2656163\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h3C0C7E4BEEEA4147; + z = 64'h0010000000000000; + ans = 64'h7C0C7E4BEEEA4146; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2656777\n"); + end + x = 64'h45A0000800000020; + y = 64'h3F9D5B14C2083A69; + z = 64'h439EFDFFFFFFFFFE; + ans = 64'h454D5B2373725BA8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2657391\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hBCA0000000000000; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2658005\n"); + end + x = 64'h000DFF0000000000; + y = 64'hC0800002FFFFFFFF; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2658619\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h3CA0000000000000; + z = 64'hE1BFFFFFFC1FFFFF; + ans = 64'h7C9FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2659233\n"); + end + x = 64'hC8C608DD8889617B; + y = 64'h3FDFFFFFFFEFFFE0; + z = 64'h3FD0000000000000; + ans = 64'hC8B608DD887E5CF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2659847\n"); + end + x = 64'h3FEFFFFFFFFBFFFD; + y = 64'h3CA0000000000001; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2660461\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC1F33BC4DC616C1F; + z = 64'hC010000000001040; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2661075\n"); + end + x = 64'h89D00800000007FF; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h41CF3D7795756252; + ans = 64'h41CF3D7795756252; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2661689\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h41CFDFDFFFFFFFFE; + z = 64'h0000000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2662303\n"); + end + x = 64'h46640000000001FE; + y = 64'h7FDDFFFFFFFFF7FF; + z = 64'hC1E000001FFFFF80; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2662917\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h3FD0000000000001; + z = 64'h8010000000000001; + ans = 64'h7FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2663531\n"); + end + x = 64'h402D74C2FBFA1FDB; + y = 64'h47F000000020FFFE; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h482D74C2FC36E0A9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2664145\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h41F0007FFFC00000; + ans = 64'h7FDFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2664759\n"); + end + x = 64'h13601FDFFFFFFFFE; + y = 64'hC1D00000000201FF; + z = 64'h43DEC9C680E70DAB; + ans = 64'h43DEC9C680E70DAB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2665373\n"); + end + x = 64'hC34F87FB54D961A0; + y = 64'h3FE0000000000000; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hC33F87FB54D961A0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2665987\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC13FBFFFFFFFFFFC; + z = 64'h9E0007FEFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2666601\n"); + end + x = 64'h608000000080FFFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hBE5FFFFFFEFFFFF7; + ans = 64'h608000000080FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2667215\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hB81FFFFDFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2667829\n"); + end + x = 64'hC1FFFFFFFFFE4000; + y = 64'hBFEFFF0007FFFFFE; + z = 64'h402FFFFFFFFFFF7F; + ans = 64'h41FFFF0008FE400C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2668443\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h3FF0000000000000; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2669057\n"); + end + x = 64'h405DFFFFFFFFBFFF; + y = 64'hBFC37916008602E8; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'hC02C830940FAF78E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2669671\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h47EFFFFFFFFEFFBF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2670285\n"); + end + x = 64'h800FFDFFFFFFEFFE; + y = 64'h3FF81FFFFFFFFFFF; + z = 64'h1261EBCAEBB0E94A; + ans = 64'h1261EBCAEBB0E94A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2670899\n"); + end + x = 64'hD0300004001FFFFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hD0400004001FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2671513\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC7E0000001FFBFFF; + z = 64'h9E2FFFFFFFFFF87F; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2672127\n"); + end + x = 64'hC3DFFFFFFFFBFFFB; + y = 64'h4000000000000001; + z = 64'hB81FA9628B39210C; + ans = 64'hC3EFFFFFFFFBFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2672741\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h7FDA01B736DBF682; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2673355\n"); + end + x = 64'h403EFFFFFFFF8000; + y = 64'h40D000008FFFFFFF; + z = 64'h3E205EB8191C94FC; + ans = 64'h411F000116FF801F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2673969\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2674583\n"); + end + x = 64'h8D100009FFFFFFFE; + y = 64'hBF791618C4CC930D; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2675197\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h4010000000000001; + z = 64'hC3EFFFDFE0000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2675811\n"); + end + x = 64'h2E6FFFFFE2000000; + y = 64'h47E00FFFFFFFFFF8; + z = 64'hBFEF00000003FFFE; + ans = 64'hBFEF00000003FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2676425\n"); + end + x = 64'h6C9FE000007FFFFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hBCA0000000000000; + ans = 64'h6CCFE000007FFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2677039\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h40E00000000003F0; + z = 64'hC1C401FFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2677653\n"); + end + x = 64'hC34FFFF8FFFFFFFF; + y = 64'h4340000000000000; + z = 64'h381FFFFFFEFFFFFA; + ans = 64'hC69FFFF8FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2678267\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hDC0F7FFFDFFFFFFF; + z = 64'hFFE0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2678881\n"); + end + x = 64'h5BA89D8E76702695; + y = 64'h403FFBFFFFFFDFFF; + z = 64'h402007FFFFFFFFFC; + ans = 64'h5BF89A7AC4A13FF2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2679495\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2680109\n"); + end + x = 64'hC02FFFFDFFFFBFFF; + y = 64'hBFAFFFFDFFFF8000; + z = 64'h3FF0000000000001; + ans = 64'h3FFFFFFDFFFFB001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2680723\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'h402FE00001FFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2681337\n"); + end + x = 64'hFFF0007FFFFFFFF0; + y = 64'hC1CFFFDFFEFFFFFF; + z = 64'hBFF0000400000000; + ans = 64'hFFF8007FFFFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2681951\n"); + end + x = 64'h380FFFFFEFDFFFFE; + y = 64'h7FE0000000000001; + z = 64'h8010000000000001; + ans = 64'h77FFFFFFEFE00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2682565\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h4C40007FFFFFFBFF; + z = 64'hFFE00010FFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2683179\n"); + end + x = 64'hFFE60948A045D052; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h416830715668BF7E; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2683793\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hB7EFFFFFFFFFFFFF; + z = 64'hC340000000000001; + ans = 64'hF7EFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2684407\n"); + end + x = 64'h43EBE98FE3471EF1; + y = 64'hC3DFFC00000001FF; + z = 64'hFFDFFFFF7FFFFFFF; + ans = 64'hFFDFFFFF7FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2685021\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h7FF0000000000001; + z = 64'h7FE0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2685635\n"); + end + x = 64'h367FEFFFFFDFFFFF; + y = 64'h3C28000000008000; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2686249\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h3FC0008FFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2686863\n"); + end + x = 64'h3FBFFFE000000007; + y = 64'h787FFFE0003FFFFE; + z = 64'h43CFFE0000001FFE; + ans = 64'h784FFFC0005FFFC5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2687477\n"); + end + x = 64'h3CA000400000007F; + y = 64'h8000000000000000; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h800FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2688091\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h3FE00000007FFEFF; + z = 64'h403FFFFE00008000; + ans = 64'h7FE00000007FFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2688705\n"); + end + x = 64'hAB80000008000020; y = 64'h800FFFFFFFFFFFFF; - z = 64'hC06FFE000000000E; - ans = 64'hC06FFE000000000E; + z = 64'hC3CFFFFFFFFFC010; + ans = 64'hC3CFFFFFFFFFC010; rn = 1; rz = 0; rm = 0; @@ -67623,12 +205897,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2896131\n"); + $fwrite(fp,"2689319\n"); end - x = 64'hC3F312D750C816D5; - y = 64'hBFBFFFD7FFFFFFFE; - z = 64'h381F7FFFFFFFFBFE; - ans = 64'h43C312BF793AF1DA; + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hB801FFFDFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hF801FFFDFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -67670,10 +205944,10538 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2898145\n"); + $fwrite(fp,"2689933\n"); end - x = 64'h7FF0000000000001; + x = 64'hC00FFFC003FFFFFF; + y = 64'hFFE003FFFEFFFFFF; + z = 64'h3FEE3B6F7416A277; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2690547\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h8010000000000000; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2691161\n"); + end + x = 64'hE100000080000006; + y = 64'hC04FFFFFFFFE000F; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h616000007FFF000D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2691775\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h8010000000000001; + z = 64'h381FFFF802000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2692389\n"); + end + x = 64'h40B0048000000000; + y = 64'h3FE3ED76B6489C1D; + z = 64'h3E7FBFFFFFFFFFBF; + ans = 64'h40A3F3117FAFD889; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2693003\n"); + end + x = 64'h41DFFFFFFF7FF000; y = 64'h801FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2693617\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h41C000000000013E; + z = 64'hFFF004000003FFFE; + ans = 64'hFFF804000003FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2694231\n"); + end + x = 64'hF7D00001F7FFFFFF; + y = 64'hBCA0000000000001; + z = 64'h7FD0000000017FFF; + ans = 64'h7FD0000000017FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2694845\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hBA6FFFFFFFFFFFEB; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hFA6FFFFFFFFFFFEA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2695459\n"); + end + x = 64'h43F04EE0AE1C051B; + y = 64'hC0700FDFFFFFFFFE; + z = 64'hB7F1FFFFFEFFFFFF; + ans = 64'hC4705F0EF108C4E6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2696073\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'hFCAFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2696687\n"); + end + x = 64'h3FA00400000007FF; + y = 64'h0014DB112901A6D9; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2697301\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hBFD0000000000000; + z = 64'h41F03FFFFFE00000; + ans = 64'hFFCFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2697915\n"); + end + x = 64'hB812000000080000; + y = 64'hC24FFFFFFF00003F; + z = 64'hB98FE003FFFFFFFF; + ans = 64'h3A71FFC03F700023; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2698529\n"); + end + x = 64'hBCDFFFFFFE1FFFFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2699143\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC03FFFFDFFFDFFFE; + z = 64'h3FFFBFFFFFF7FFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2699757\n"); + end + x = 64'h3FB000000100007F; + y = 64'hBFE0000000000000; + z = 64'hC00008001FFFFFFF; + ans = 64'hC000480020040001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2700371\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hD0126E987899EAFF; + z = 64'hC000000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2700985\n"); + end + x = 64'hBC8117A78D57DE17; + y = 64'hBFE0000001FFFBFF; + z = 64'hC3FA1CA7FD3C5593; + ans = 64'hC3FA1CA7FD3C5593; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2701599\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h4010000000000000; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2702213\n"); + end + x = 64'h434DFFFFFFFFFFDE; + y = 64'h71E86FF6019437FA; + z = 64'h3CA0000000000001; + ans = 64'h7546E8F6A17AF460; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2702827\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h3C63CCE2F498B2CB; + ans = 64'hFFEFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2703441\n"); + end + x = 64'hC74B7FFFFFFFFFFE; + y = 64'hBFF000001000003F; + z = 64'hC0E0000002000007; + ans = 64'h474B80001B80006A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2704055\n"); + end + x = 64'h83BFFC7FFFFFFFFF; + y = 64'hBFF0000000000001; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2704669\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h3FD8E249A50C7C32; + z = 64'h38101FFFFFFFFFC0; + ans = 64'h7FD8E249A50C7C31; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2705283\n"); + end + x = 64'hC1E0000400000100; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h408FF77FFFFFFFFF; + ans = 64'h41F000043FEF00FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2705897\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h04B0DDD888155295; + z = 64'hBFF0000000000001; + ans = 64'h44B0DDD888155294; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2706511\n"); + end + x = 64'hC034B755456A5C7C; + y = 64'h41E0000000000000; + z = 64'hBF1FFFFFFF7FFC00; + ans = 64'hC224B755456A5C8C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2707125\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC000000000000001; + z = 64'h4000000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2707739\n"); + end + x = 64'h3F4FFFEFFDFFFFFF; + y = 64'hC1F40DF17AEAA200; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hC1540DE772B10572; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2708353\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h66700003FFDFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2708967\n"); + end + x = 64'hBFEFFFFFFFFFC000; + y = 64'h002080000000000F; + z = 64'h0B9FFFFC0000007F; + ans = 64'h0B9FFFFC0000007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2709581\n"); + end + x = 64'h40500000007FFDFF; + y = 64'hC010000000000000; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2710195\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC7E1FFFFFFFFFFFC; + z = 64'hC7D6500338CDEEFD; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2710809\n"); + end + x = 64'hBEDFFF800000003E; + y = 64'hC010000000000001; + z = 64'h3FF0000400000007; + ans = 64'h3FF00023FF800007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2711423\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h3FE0001000000007; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'h7FE0001000000006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2712037\n"); + end + x = 64'hBFC000000020000F; + y = 64'hC3488494D9B089E2; + z = 64'h400953DDF7890BE9; + ans = 64'h43188494D9E1932F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2712651\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC340000000000000; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2713265\n"); + end + x = 64'h37E0080000020000; + y = 64'h3FC9D48FACB73124; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h37B9E179F490C74F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2713879\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC340000000000001; + z = 64'h3FBFDFFFFFFEFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2714493\n"); + end + x = 64'h45C000003FFFFFFF; + y = 64'hC56FFFFF8003FFFF; + z = 64'h4DF00000080007FF; + ans = 64'h4DF00000080005FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2715107\n"); + end + x = 64'h403FFFC000000FFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'hC39FFFC000000FFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2715721\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h41CFFDFFFFFFFC00; + z = 64'hC1DFF80100000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2716335\n"); + end + x = 64'h92FCBDCB2FA72585; + y = 64'hFFE0000000000000; + z = 64'h3DFFC0000001FFFF; + ans = 64'h52ECBDCB2FA72585; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2716949\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC3C00400000007FE; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2717563\n"); + end + x = 64'hBCA0000000010010; + y = 64'hC3CFC00000000002; + z = 64'hB7E0003FFFFFFFDF; + ans = 64'h407FC0000001FC22; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2718177\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2718791\n"); + end + x = 64'hC0EFFFDFFFFFFBFF; + y = 64'hBE3FFFFFFF7FFC00; + z = 64'h0000000000000000; + ans = 64'h3F3FFFDFFF7FF87F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2719405\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hFFF0000000000000; + z = 64'h801FFFFFFFFFFFF4; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2720019\n"); + end + x = 64'hC3DFFDFFFFFFFC00; + y = 64'hC7EFFC0000000000; + z = 64'h3FD007FFFFFFFFBF; + ans = 64'h4BDFFA003FFFFC01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2720633\n"); + end + x = 64'h7FDFFFFFFFF87FFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h4010000000000000; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2721247\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hB7F0007FFFFDFFFF; + z = 64'h41D00009FFFFFFFF; + ans = 64'hF7F0007FFFFDFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2721861\n"); + end + x = 64'h41F000007FFEFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h31620000000001FF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2722475\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBCAE75B7DA64DA8B; + z = 64'hBFD0000000000000; + ans = 64'hFCAE75B7DA64DA89; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2723089\n"); + end + x = 64'h400000000004001F; + y = 64'hB23FFFFFC2000000; + z = 64'hC0303FFFFFDFFFFF; + ans = 64'hC0303FFFFFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2723703\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3FE0000000000000; + ans = 64'h4011FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2724317\n"); + end + x = 64'h37FFFFFF7FFFFFDE; + y = 64'h3FE0004400000000; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2724931\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h801AD09F91401F94; + ans = 64'h400FFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2725545\n"); + end + x = 64'h510FE00000000004; + y = 64'h3FC00000010007FF; + z = 64'h7FDFBF0000000000; + ans = 64'h7FDFBF0000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2726159\n"); + end + x = 64'h480F30C3D189FBF8; + y = 64'h0010000000000001; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2726773\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h801FC40000000000; + z = 64'h405BFFFFEFFFFFFF; + ans = 64'h405A03BFEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2727387\n"); + end + x = 64'h8F6FFFFFFFFFFF3F; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h3E70403FFFFFFFFF; + ans = 64'h3E70403FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2728001\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hCA60000000003FBF; + z = 64'hBCA0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2728615\n"); + end + x = 64'hFFD000007FBFFFFF; + y = 64'h409529DF079AEA06; + z = 64'hC1F000002000000F; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2729229\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3CA0000000000001; + z = 64'h3FD0000000000001; + ans = 64'h7CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2729843\n"); + end + x = 64'hC1BFFC0000FFFFFE; + y = 64'hC8000001FFC00000; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2730457\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hBFF0007FFFFF7FFF; + ans = 64'h7CAFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2731071\n"); + end + x = 64'hC3431371803FAF5C; + y = 64'hC01E02B00FBA67F6; + z = 64'hBECE7C5499D55A61; + ans = 64'h4371E3D493A435F1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2731685\n"); + end + x = 64'h47E07FFFFFFFFFBE; + y = 64'h3FD0000000000000; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h47C07FFFFFFFFFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2732299\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hED7FFFFFFFFFE007; + z = 64'hDDCE000000800000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2732913\n"); + end + x = 64'hAE3FFFFFF7FFFF7F; + y = 64'h3FD0000000000001; + z = 64'h3EB0000200007FFF; + ans = 64'h3EB0000200007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2733527\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h4018AD954FA2661C; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2734141\n"); + end + x = 64'hC3F0000001FFFF7E; + y = 64'hBD80008000001FFF; + z = 64'hC3CFFFFFC1FFFFFE; + ans = 64'hC3CFFFFFC1FEFFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2734755\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3FE0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2735369\n"); + end + x = 64'hC005FFFFFFFFFFFF; + y = 64'h00131D0C934B03B5; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2735983\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3FE0000000000001; + z = 64'hC01000003E000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2736597\n"); + end + x = 64'h3410007FFFFFFFF0; + y = 64'h3FDFFFFE07FFFFFF; + z = 64'hB7E42BFC32088109; + ans = 64'hB7E42BFC32088109; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2737211\n"); + end + x = 64'h40C9F9C3F5F48C89; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h40C9FA43F5F48C87; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2737825\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h56EE000003FFFFFF; + z = 64'h480EFFFFFFFF8000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2738439\n"); + end + x = 64'h6152307E846B6B2F; + y = 64'h3FF0000000000000; + z = 64'h3FBBFFFFFFFFFF7E; + ans = 64'h6152307E846B6B2F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2739053\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3FCFFFFFF7FFFFFE; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h7FCFFFFFF7FFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2739667\n"); + end + x = 64'hC060FFFFFFFFFFFB; + y = 64'hC03BE00000000000; + z = 64'hBFC1625D444CD847; + ans = 64'h40AD9DBA768AEEC4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2740281\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2740895\n"); + end + x = 64'h3FDFFFFFFC000FFE; + y = 64'h7FEC0FE52F009BCC; + z = 64'hC340000000000000; + ans = 64'h7FDC0FE52B7EAD2C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2741509\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h4000000000000000; + z = 64'h408FFEFFFFFFFFFB; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2742123\n"); + end + x = 64'h4DFFFFFD00000000; + y = 64'hC212000000000000; + z = 64'h43D00003FEFFFFFF; + ans = 64'hD021FFFE50000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2742737\n"); + end + x = 64'h3E3FFFFFFFFFDFBE; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000010000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2743351\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hC801A4C88B03EBDD; + z = 64'h402F800020000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2743965\n"); + end + x = 64'hB26FFFFC00000003; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h84B00007FFFFFFF7; + ans = 64'hB28FFFFC00000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2744579\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hC00130F25C0FC4FE; + z = 64'h8000000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2745193\n"); + end + x = 64'h404087982EBE099A; + y = 64'hBFBFFBFFFFFF0000; + z = 64'h403004000FFFFFFF; + ans = 64'h4027C53C82242930; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2745807\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h0010000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2746421\n"); + end + x = 64'h403249857D09F98B; + y = 64'h402FFFE000000020; + z = 64'hC010000000000001; + ans = 64'h4072097333847C93; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2747035\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h001DB6DB217A3447; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2747649\n"); + end + x = 64'hB1A0000000000000; + y = 64'h402001FFFFFEFFFE; + z = 64'h403FFFFFFC000002; + ans = 64'h403FFFFFFC000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2748263\n"); + end + x = 64'h6DD07FFFFFFFFFF6; + y = 64'h4340000000000001; + z = 64'h3FD0000000000001; + ans = 64'h71207FFFFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2748877\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hC00FFFFFEFFEFFFF; + z = 64'h3D900000803FFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2749491\n"); + end + x = 64'h3F90000000800000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFE01; + ans = 64'hFFFFFFFFFFFFFE01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2750105\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBFE0000000002007; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2750719\n"); + end + x = 64'h37EFFBFFFFFFC000; + y = 64'h378FFBFFFFFFFF7F; + z = 64'h427766C3FF898D65; + ans = 64'h427766C3FF898D65; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2751333\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'h0000000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2751947\n"); + end + x = 64'h4440008000000000; + y = 64'h038ABB97FC6031CE; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2752561\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h801EDFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2753175\n"); + end + x = 64'hBE40203FFFFFFFFF; + y = 64'h3FB0000280000000; + z = 64'hBAA4591950B7103C; + ans = 64'hBE0020428509FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2753789\n"); + end + x = 64'h7FDFFFFFFFFE001F; + y = 64'h7FF0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2754403\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3C3FFFFFFFFF007E; + z = 64'h3F4FFFFE000000FE; + ans = 64'h7C3FFFFFFFFF007C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2755017\n"); + end + x = 64'hC02FFFFFFFFC0007; + y = 64'h7FF0000000000001; + z = 64'hC3F0000037FFFFFE; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2755631\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBFBFF80000002000; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEC00FFFFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2756245\n"); + end + x = 64'h3FEC0FFFFFFFFFFE; + y = 64'h37E0082000000000; + z = 64'hC0305FFFFFFFFFFF; + ans = 64'hC0305FFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2756859\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2757473\n"); + end + x = 64'h800FF81FFFFFFFFF; + y = 64'hC02FFFEC00000000; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2758087\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h8000000000000001; + z = 64'h44B1D069FC89E1A4; + ans = 64'h44B1D069FC89E1A4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2758701\n"); + end + x = 64'hFFF000000005FFFF; + y = 64'hC80FFFFFFFFBDFFF; + z = 64'h800FFFFFFEFFDFFF; + ans = 64'hFFF800000005FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2759315\n"); + end + x = 64'h475426384B2F52FF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h877426384B2F52FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2759929\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hC083FFFDFFFFFFFF; + z = 64'h41F00000000400FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2760543\n"); + end + x = 64'hBFB000000001EFFF; + y = 64'h8010000000000000; + z = 64'hC010000000000010; + ans = 64'hC010000000000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2761157\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3FD45C4A28015794; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h7FD45C4A28015793; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2761771\n"); + end + x = 64'hC003A9DCAAEBFAEA; + y = 64'h7FD8000000000006; + z = 64'hC7F2253D67209A0F; + ans = 64'hFFED7ECB0061F866; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2762385\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2762999\n"); + end + x = 64'hE8D00000800FFFFF; + y = 64'h3FE000400000000F; + z = 64'hBFF0000000000000; + ans = 64'hE8C000408012004E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2763613\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBCA0000000000000; + z = 64'h000020000001FFFF; + ans = 64'hFC9FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2764227\n"); + end + x = 64'h3E430E36893A9156; + y = 64'hB85FFFBFFFE00000; + z = 64'h47F000003FFDFFFE; + ans = 64'h47F000003FFDFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2764841\n"); + end + x = 64'h41CFFFFFFFFFF008; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h0010000000000000; + ans = 64'hBE8FFFFFFFFFF007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2765455\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h7FDFEFFFFFDFFFFE; + z = 64'h3FD00000FFFF7FFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2766069\n"); + end + x = 64'hC06822393DB1B5D9; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h34C001000000003E; + ans = 64'h3D2822393DB1B5D7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2766683\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h480FFFFFFFFDFFBF; + z = 64'h4340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2767297\n"); + end + x = 64'h402FFFF803FFFFFF; + y = 64'hBFD00000020001FE; + z = 64'hCDE000007FFFFFF0; + ans = 64'hCDE000007FFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2767911\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBFD0000000000001; + z = 64'hFFE0000000000000; + ans = 64'hFFE8000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2768525\n"); + end + x = 64'h381F80000000003F; + y = 64'hBC0C24FFA891303C; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2769139\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBA10000000000EFE; + ans = 64'hFFDFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2769753\n"); + end + x = 64'h4037FFFFFFFFFFFA; + y = 64'hC31FFF8FFFFFFFFE; + z = 64'hC1700007FFFFFC00; + ans = 64'hC367FFAC00200009; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2770367\n"); + end + x = 64'h000FFFFFFFF00006; + y = 64'hBFE0000000000001; + z = 64'h0000000000000001; + ans = 64'h8007FFFFFFF80002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2770981\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hC1C00FFFFFBFFFFF; + z = 64'hBFFFFFFFEFC00000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2771595\n"); + end + x = 64'hC03FFFFDFFFFC000; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h51FFFFFFFFC00000; + ans = 64'h51FFFFFFFFC00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2772209\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h41F00003FFFFFFFB; + z = 64'h4010000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2772823\n"); + end + x = 64'h2DD2641B75C4C4DE; + y = 64'hC340800000000100; + z = 64'hC020000000000000; + ans = 64'hC020000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2773437\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBFF0000000000000; + z = 64'hC340000000000001; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2774051\n"); + end + x = 64'hBFE79A9AE98115B0; + y = 64'hBE70000100000000; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFD0CAC739; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2774665\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hC80000000100001F; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2775279\n"); + end + x = 64'h47F000000FFFFFEF; + y = 64'h37F0BA5592D6B7C6; + z = 64'h3FBFFFFFFF000000; + ans = 64'h3FF2BA55A3810D47; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2775893\n"); + end + x = 64'h7FF3FFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2776507\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3420007FFFFFFFFC; + z = 64'h4010404000000000; + ans = 64'h7420007FFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2777121\n"); + end + x = 64'h41EBFFEFFFFFFFFF; + y = 64'hC000000000000001; + z = 64'hC34605A8B553962B; + ans = 64'hC34605A99553162B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2777735\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h41CC4B5F23ACBE96; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2778349\n"); + end + x = 64'h8170000103FFFFFE; + y = 64'h3FDFFFFFFF00FFFF; + z = 64'h22A5204FB3D18829; + ans = 64'h22A5204FB3D18829; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2778963\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2779577\n"); + end + x = 64'hC3DFFF003FFFFFFE; + y = 64'h7FF000000020003E; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'h7FF800000020003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2780191\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hC010000000000001; + z = 64'hC1DFFBFFFE000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2780805\n"); + end + x = 64'hBFBFFFFEFFFBFFFF; + y = 64'hD40FFFFF000003FF; + z = 64'hBFB2000002000000; + ans = 64'h53DFFFFDFFFC0BFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2781419\n"); + end + x = 64'hC020000000000100; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2782033\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h380010000003FFFE; + z = 64'h43F1FFFFBFFFFFFF; + ans = 64'h780010000003FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2782647\n"); + end + x = 64'h466FFFFFF0001FFE; + y = 64'hC340000000000000; + z = 64'hC15000000008007F; + ans = 64'hC9BFFFFFF0001FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2783261\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h802FC00200000000; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'hC02BC001FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2783875\n"); + end + x = 64'hBFF0000001000000; + y = 64'h5700000080000003; + z = 64'h41C00100000000FF; + ans = 64'hD70000008100000B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2784489\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2785103\n"); + end + x = 64'h37E3FFFFFFFFFBFF; + y = 64'hBEF3431D1F903239; + z = 64'hBCA0000000000000; + ans = 64'hBCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2785717\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hFFE0000000000000; + z = 64'hBB6FFFBFFFDFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2786331\n"); + end + x = 64'h43C8874EB3D8AEE2; + y = 64'hA87FFFFFFFFDFFFF; + z = 64'hBFF001FFFFFFFFFE; + ans = 64'hBFF001FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2786945\n"); + end + x = 64'hC3500003FFEFFFFE; + y = 64'hFFE0000000000001; + z = 64'hFFE0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2787559\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hC1EFE007FFFFFFFF; + z = 64'hC7F0000008000020; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2788173\n"); + end + x = 64'hBE40F691785FA275; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hB35FFF803FFFFFFF; + ans = 64'h7E40F691785FA274; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2788787\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h4346719A05C360D1; + z = 64'h3FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2789401\n"); + end + x = 64'hC7F0991CCB0BBE1F; + y = 64'h400FFF7FFFFEFFFE; + z = 64'hFFD4000000020000; + ans = 64'hFFD4000000020000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2790015\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hFFF0000000000001; + z = 64'hC000000000000000; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2790629\n"); + end + x = 64'h423000000002000F; + y = 64'hBF5DFF2DE9D3F850; + z = 64'h8010000000000001; + ans = 64'hC19DFF2DE9D7B852; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2791243\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hC2E1C2B66781392C; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2791857\n"); + end + x = 64'h308D3F161CAAD5D4; + y = 64'h475FFFFFFFC00FFE; + z = 64'h3FEF86854B517225; + ans = 64'h3FEF86854B517225; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2792471\n"); + end + x = 64'h47EFFFFFFFFD7FFF; + y = 64'h0000000000000000; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2793085\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBCAFFBFFE0000000; + z = 64'hC3FFFFFDFFFFFFF0; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2793699\n"); + end + x = 64'h4010FFFFFF7FFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC7E0000040000100; + ans = 64'hC7E0000040000100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2794313\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3FCFFFFFFFFFB800; + z = 64'h3FE0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2794927\n"); + end + x = 64'h402000000003C000; + y = 64'h2BBFFFFFE0000003; + z = 64'hC3D9F0847445CB73; + ans = 64'hC3D9F0847445CB73; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2795541\n"); + end + x = 64'h7FF0000000000000; + y = 64'h0010000000000000; + z = 64'hBFF0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2796155\n"); + end + x = 64'h3F20003EFFFFFFFF; + y = 64'hBFF0000000800020; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'hBF20003F00800217; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2796769\n"); + end + x = 64'h7FF0000000000000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hB5FFFFFFDFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2797383\n"); + end + x = 64'h3FD0000000010007; + y = 64'h3F9FFDFFFFFC0000; + z = 64'h043FFFFF00000800; + ans = 64'h3F7FFDFFFFFDFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2797997\n"); + end + x = 64'h802C7082F2D15588; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2798611\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC1800002FFFFFFFF; + z = 64'hC3CFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2799225\n"); + end + x = 64'h37F0000000FFFFFF; + y = 64'h3CA0000000000001; + z = 64'h3EF4E84F0DAF7946; + ans = 64'h3EF4E84F0DAF7946; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2799839\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBFFFFF0000000020; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2800453\n"); + end + x = 64'h3FFFFFFFEFFFFFDF; + y = 64'h405F7FFEFFFFFFFF; + z = 64'hBFC8313D186FF150; + ans = 64'h406F79F2A0F9E462; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2801067\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2801681\n"); + end + x = 64'h417FFFC040000000; + y = 64'h3CA00007FFC00000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2802295\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3FD0000000000001; + z = 64'hC34FFDFFFFFFFF7F; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2802909\n"); + end + x = 64'hF0C0003FFFFFFFFC; + y = 64'hBFC040000FFFFFFE; + z = 64'hC018E3FC97500574; + ans = 64'h7090404110003FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2803523\n"); + end + x = 64'hFF0FB3A76863C927; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hFEFFB3A76863C926; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2804137\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC3E00087FFFFFFFE; + z = 64'h480FFFFFFFDFFFF6; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2804751\n"); + end + x = 64'hC80000007F7FFFFF; + y = 64'h3FE0000000000000; + z = 64'hB64007FFFFFEFFFF; + ans = 64'hC7F000007F7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2805365\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC8007FFFFFFFDFFF; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2805979\n"); + end + x = 64'h402FFF807FFFFFFF; + y = 64'h37FC8B335383047F; + z = 64'h4340200000080000; + ans = 64'h4340200000080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2806593\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2807207\n"); + end + x = 64'hC3C0000088000000; + y = 64'hC34A8A318C8B3E44; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2807821\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3FF0000000000000; + z = 64'h7FEDFFFFFFBFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2808435\n"); + end + x = 64'hFFFFFE0000000004; + y = 64'h4270000000010FFF; + z = 64'hB84FFFFF7FF7FFFF; + ans = 64'hFFFFFE0000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2809049\n"); + end + x = 64'h43A03FFFFFFEFFFF; + y = 64'h3FF0000000000001; + z = 64'hC000000000000000; + ans = 64'h43A03FFFFFFF0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2809663\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBFAFFFFFFE1FFFFF; + z = 64'hB7FFFFFC08000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2810277\n"); + end + x = 64'h47F0000000FFFDFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC1DFFFFFFFFFFEF6; + ans = 64'h4800000000FFFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2810891\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3EAF800000008000; + z = 64'h3CA0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2811505\n"); + end + x = 64'h5BEFFFFFFFFFEFFE; + y = 64'h7FFFFFFC007FFFFF; + z = 64'hC1EFFFFFFEDFFFFF; + ans = 64'h7FFFFFFC007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2812119\n"); + end + x = 64'h7FF0000000000000; + y = 64'h4000000000000001; + z = 64'hBFD0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2812733\n"); + end + x = 64'hBFF80F7B17E98453; + y = 64'hC3D6E30A5A94BC09; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2813347\n"); + end + x = 64'h7FF0000000000000; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hBC5E24D175FF8E44; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2813961\n"); + end + x = 64'h4803CCEB031B60A4; + y = 64'h796A522F02E82FC6; + z = 64'h480C776C5FE298B2; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2814575\n"); + end + x = 64'h403FFDFFFBFFFFFE; + y = 64'h4010000000000000; + z = 64'hBFF0000000000001; + ans = 64'h405FBDFFFBFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2815189\n"); + end + x = 64'h7FF0000000000000; + y = 64'h401FE00000002000; + z = 64'h47E000001FFBFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2815803\n"); + end + x = 64'h0FC0000003FFF7FF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3F407BFFFFFFFFFE; + ans = 64'h3F407BFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2816417\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3F2000000000043E; + z = 64'h0010000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2817031\n"); + end + x = 64'hBFD000002000FFFE; + y = 64'hC8044401C84131E5; + z = 64'hBFDFFD7FFFFFFFFF; + ans = 64'h47E44401F0CA79B3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2817645\n"); + end + x = 64'h7FF0000000000000; + y = 64'h4340000000000000; + z = 64'hBCA0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2818259\n"); + end + x = 64'hC1F9782AAEE2F6E6; + y = 64'h41F9D1C5D52EC00A; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'hC4048AD7A4DB6198; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2818873\n"); + end + x = 64'h7FF0000000000000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h41CFFFFEFFFDFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2819487\n"); + end + x = 64'hC18403FFFFFFFFFF; + y = 64'h480FFFFFFFFFFFB7; + z = 64'hBFE00000000FFFEE; + ans = 64'hC9A403FFFFFFFFD1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2820101\n"); + end + x = 64'h800FFFFFFEF7FFFE; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2820715\n"); + end + x = 64'h7FF0000000000000; + y = 64'h40DFE00000400000; + z = 64'hC00122D1E9DB54BA; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2821329\n"); + end + x = 64'h533000000003FFF7; + y = 64'h7FE0000000000001; + z = 64'hC1E075D8BA1D5302; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2821943\n"); + end + x = 64'h7FF0000000000000; + y = 64'h41F0000FFFFF7FFF; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2822557\n"); + end + x = 64'h4000000001DFFFFF; + y = 64'h473FFFFFFFFF2000; + z = 64'h58CFFFEFFFEFFFFF; + ans = 64'h58CFFFEFFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2823171\n"); + end + x = 64'h7FF0000000000000; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2823785\n"); + end + x = 64'hBCA308379D8DFF8B; + y = 64'h41EFFFFFFFFFDEFE; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFD9EF90C3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2824399\n"); + end + x = 64'h7FF0000000000000; + y = 64'h7FF0000000000001; + z = 64'hBFAB85887638758B; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2825013\n"); + end + x = 64'h3F90000FFFFF8000; + y = 64'h3FB000FFFFEFFFFF; + z = 64'h412FEFFFFFFE0000; + ans = 64'h412FF000007E0880; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2825627\n"); + end + x = 64'hB0BEFFFFFFF7FFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2826241\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3FD0003FFFFFC000; + z = 64'h43DFFFE000000006; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2826855\n"); + end + x = 64'hB7FFFFDFFFFFF7FF; + y = 64'h8000000000000000; + z = 64'h3FBFFFFFFDFFDFFF; + ans = 64'h3FBFFFFFFDFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2827469\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBF6020000003FFFE; z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; @@ -67717,12 +216519,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2900159\n"); + $fwrite(fp,"2828083\n"); end - x = 64'hBE094AE83F023CB1; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hC02FE000001FFFFF; - ans = 64'hC02FE000001FFFFF; + x = 64'h411FFFFFFFFDFEFE; + y = 64'hB806E5E85D3FD5BC; + z = 64'hC02FFFFFFFFF7FFD; + ans = 64'hC02FFFFFFFFF7FFD; rn = 1; rz = 0; rm = 0; @@ -67764,3771 +216566,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2902173\n"); + $fwrite(fp,"2828697\n"); end - x = 64'h3F5FFFF800000FFF; - y = 64'hFFFFFFFFD7FFFFFE; - z = 64'h29F0000000001FFB; - ans = 64'hFFFFFFFFD7FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2904187\n"); - end - x = 64'h7FF0000000000001; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2906201\n"); - end - x = 64'h4000000004000000; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hBCA0000001FDFFFF; - ans = 64'hC000000004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2908215\n"); - end - x = 64'hC3CE8C81AD84B066; - y = 64'h3E30FFFFFEFFFFFF; - z = 64'h480FFE0004000000; - ans = 64'h480FFE0004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2910229\n"); - end - x = 64'h7FF0000000000001; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2912243\n"); - end - x = 64'hBFDEFFFFFFFF8000; - y = 64'hC000000000000001; - z = 64'h3FCCC2E7F3C48EEC; - ans = 64'h3FF3185CFE7851DE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2914257\n"); - end - x = 64'h401618D4ABC2ECBA; - y = 64'h3FE97989D3F9C41B; - z = 64'h3DEFFFFFFFFBFFEF; - ans = 64'h40119753370C7449; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2916271\n"); - end - x = 64'h7FF0000000000001; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2918285\n"); - end - x = 64'hC64000000803FFFE; - y = 64'hC340000000000001; - z = 64'h434000000FFFFDFE; - ans = 64'h499000000803FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2920299\n"); - end - x = 64'hB81FFFFFFFFFFFBA; - y = 64'hC00F001FFFFFFFFF; - z = 64'hC080000001FFF800; - ans = 64'hC080000001FFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2922313\n"); - end - x = 64'h7FF0000000000001; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2924327\n"); - end - x = 64'h002FFFFFEFFFFFFF; - y = 64'hFFF0000000000001; - z = 64'hFFDFFFF000000008; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2926341\n"); - end - x = 64'hFFD00000000BFFFE; - y = 64'hBFC400003FFFFFFE; - z = 64'h3FEFFFE008000000; - ans = 64'h7FA40000400EFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2928355\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2930369\n"); - end - x = 64'hC80F800000000080; - y = 64'h0010000000000000; - z = 64'h993FFFFFFFD00000; - ans = 64'h993FFFFFFFD00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2932383\n"); - end - x = 64'hBFDCE145472B2459; - y = 64'hC1DFFC3FFFFFFFFE; - z = 64'hC3FFFBFFFFFEFFFF; - ans = 64'hC3FFFBFFFFFB6443; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2934397\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3CA0000000000001; - z = 64'hBFF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2936411\n"); - end - x = 64'h431FF800000000FF; - y = 64'h3FD0000000000000; - z = 64'h407FFFFFBFFFFF7F; - ans = 64'h42FFF800000020FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2938425\n"); - end - x = 64'hC7FFF0000001FFFF; - y = 64'h37F0000201FFFFFF; - z = 64'hC3DE6DD4C49D6691; - ans = 64'hC3DE6DD4C49D6691; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2940439\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3FE0000000000001; - z = 64'h4340000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2942453\n"); - end - x = 64'h34F746586AADAF16; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'hC9BFFFFFFFFBFEFF; - ans = 64'hC9BFFFFFFFFBFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2944467\n"); - end - x = 64'hBFF00000107FFFFF; - y = 64'hC052F75C56A2DD94; - z = 64'hBFD0005FFFFFFFFF; - ans = 64'h4052E75C0A31F4CC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2946481\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'h4000000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2948495\n"); - end - x = 64'hBDA01000000000FF; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h3FCFFE3FFFFFFFFF; - ans = 64'h3FCFFE3FFFEFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2950509\n"); - end - x = 64'hC3A0000004000001; - y = 64'hBF8EFFFEFFFFFFFE; - z = 64'h3CFFFFFFFFBFF7FF; - ans = 64'h433EFFFF07BFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2952523\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'h4340000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2954537\n"); - end - x = 64'h7FEFFFFFFE00007F; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hC1FFF80000003FFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2956551\n"); - end - x = 64'hC02FF80000000002; - y = 64'h119215FB360E73AC; - z = 64'h114000200000000E; - ans = 64'h91D20975A740F010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2958565\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'h7FF0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2960579\n"); - end - x = 64'h8DEFFFFFBF7FFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hFFDFFFFFFDFF7FFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2962593\n"); - end - x = 64'h8010000007F7FFFF; - y = 64'hFFDC0FFFFFFFFFFE; - z = 64'h3FEFC00000003FFE; - ans = 64'h4005F80006FD0BFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2964607\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2966621\n"); - end - x = 64'hC020000000000240; - y = 64'h801FFFFFFFFFFFFF; - z = 64'h3FE00003FFFFFDFE; - ans = 64'h3FE00003FFFFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2968635\n"); - end - x = 64'hC030000000002200; - y = 64'hC3445F5D4A0CA2D2; - z = 64'hC01FFFDFFDFFFFFF; - ans = 64'h43845F5D4A0CCE1C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2970649\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2972663\n"); - end - x = 64'h9F900001FFFFFFFD; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hC7F0000010000040; - ans = 64'hC7F0000010000040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2974677\n"); - end - x = 64'hFFF0000003FFFFFF; - y = 64'h00200000001FFFFF; - z = 64'h50A7FFFFFFFFFDFF; - ans = 64'hFFF8000003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2976691\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2978705\n"); - end - x = 64'h799FF80002000000; - y = 64'hBFF0000000000001; - z = 64'hC7E5E498809D2665; - ans = 64'hF99FF80002000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2980719\n"); - end - x = 64'hDA091019619C2FB6; - y = 64'hE700000000401000; - z = 64'h3CAFFEC000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2982733\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2984747\n"); - end - x = 64'h4022E75B40B8C691; - y = 64'hC010000000000001; - z = 64'hBFD2FFED1D2049E5; - ans = 64'hC0430D5B1AF30726; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2986761\n"); - end - x = 64'h3D400000000200FE; - y = 64'hC074C153DEFA227D; - z = 64'h5290000000203FFF; - ans = 64'h5290000000203FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2988775\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2990789\n"); - end - x = 64'h7FEFFBDFFFFFFFFE; - y = 64'hFFE0000000000000; - z = 64'hA87FFFFFFFFFE07F; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2992803\n"); - end - x = 64'h40110F9BDBB44785; - y = 64'h3F8FF7FFFDFFFFFF; - z = 64'h7FEFFFFBFFFFFFF8; - ans = 64'h7FEFFFFBFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2994817\n"); - end - x = 64'h7FFFFFFFFFFFFFFF; - y = 64'hFFF0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2996831\n"); - end - x = 64'h7FD03FFFFFBFFFFF; - y = 64'h0000000000000000; - z = 64'h3FFFFFFF00003FFE; - ans = 64'h3FFFFFFF00003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2998845\n"); - end - x = 64'h7FD116B80FD8533D; - y = 64'hC1DFFFFC0000003F; - z = 64'hB4B491B7E5F4A9B2; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3000859\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'h0010000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3002873\n"); - end - x = 64'h380E83F329A88838; - y = 64'h3CA0000000000000; - z = 64'hC0000000000BFFFF; - ans = 64'hC0000000000BFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3004887\n"); - end - x = 64'h405FFFFDFFFFFFBF; - y = 64'h3EE0020008000000; - z = 64'h434000006FFFFFFF; - ans = 64'h434000006FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3006901\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'h3FD0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3008915\n"); - end - x = 64'hC047E499DDFA806A; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'hB7FE0FFFFFFFFFFF; - ans = 64'hC037E499DDFA8069; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3010929\n"); - end - x = 64'h40007FFFFFE00000; - y = 64'h43E0020000000400; - z = 64'h800C91E3CE379553; - ans = 64'h43F0820FFFE00020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3012943\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'h3FF0000000000000; - z = 64'hC340000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3014957\n"); - end - x = 64'h3FBFFFFEFFFFF800; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hC340FFFFFFFFFDFF; - ans = 64'hC340FFFFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3016971\n"); - end - x = 64'hA440000003E00000; - y = 64'hBF9748F93642BBE3; - z = 64'hB7F4721D96C17B0B; - ans = 64'hB7F4721D96C17B0B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3018985\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'h4010000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3020999\n"); - end - x = 64'h35B10000000FFFFF; - y = 64'h401FFFFFFFFFFFFE; - z = 64'h59B792D483A7542C; - ans = 64'h59B792D483A7542C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3023013\n"); - end - x = 64'h401080003FFFFFFF; - y = 64'h3DC0000000001FFC; - z = 64'h218FFFF80FFFFFFF; - ans = 64'h3DE08000400020FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3025027\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'h7FE0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3027041\n"); - end - x = 64'hBFCFFFFFFFFFF004; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'hF5700000000800FE; - ans = 64'hFFCFFFFFFFFFF003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3029055\n"); - end - x = 64'hBFE6CD7171563B62; - y = 64'hFFEBF7FFFFFFFFFE; - z = 64'hC34FFC00000000FF; - ans = 64'h7FE3EE0FE6CF1E65; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3031069\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3033083\n"); - end - x = 64'h400F58F62FF4033A; + x = 64'h7FF0000000000000; y = 64'h800FFFFFFFFFFFFF; - z = 64'h401FDFFFFFFFFDFF; - ans = 64'h401FDFFFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3035097\n"); - end - x = 64'hC7FFFE0003FFFFFE; - y = 64'hC02AC90ECD6770E9; - z = 64'h3F7C001FFFFFFFFF; - ans = 64'h483AC7623FD3BC4A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3037111\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3039125\n"); - end - x = 64'hBFA01FFFFFFFFFE0; - y = 64'hBCA0000000000001; - z = 64'hC0204D08EEA95A99; - ans = 64'hC0204D08EEA95A99; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3041139\n"); - end - x = 64'h47F00000000FC000; - y = 64'h37F01FFFFFFFFDFF; - z = 64'h7FD0000040001FFF; - ans = 64'h7FD0000040001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3043153\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3045167\n"); - end - x = 64'h400FF80000000400; - y = 64'hBFE0000000000001; - z = 64'hC3B18CA640A90418; - ans = 64'hC3B18CA640A90418; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3047181\n"); - end - x = 64'h3D2FFFFBFFFFFFFE; - y = 64'h434E000000000003; - z = 64'hBFF0000040FFFFFF; - ans = 64'h408DF7FC3FDF8001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3049195\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3051209\n"); - end - x = 64'h3FFFFFFFFF7F8000; - y = 64'hC000000000000001; - z = 64'hC0B0000800FFFFFE; - ans = 64'hC0B0040800FFEFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3053223\n"); - end - x = 64'hC12FC00001000000; - y = 64'hC1E00002000003FE; - z = 64'hFFDFFFFFBFF7FFFF; - ans = 64'hFFDFFFFFBFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3055237\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3057251\n"); - end - x = 64'h40A200000000FFFE; - y = 64'hC340000000000000; - z = 64'hBFDAE1EBBB840DBC; - ans = 64'hC3F200000000FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3059265\n"); - end - x = 64'hC1F03FFFF7FFFFFF; - y = 64'h41D0000000BFFFFF; - z = 64'hC090000001007FFF; - ans = 64'hC3D03FFFF8C2FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3061279\n"); - end - x = 64'h7FFFFFFFFFFFFFFE; - y = 64'hFFE0000000000001; - z = 64'hC340000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3063293\n"); - end - x = 64'h638FFFFFFC000FFE; - y = 64'hFFF0000000000000; - z = 64'h3FD36CFBCEB8EEED; + z = 64'h800FFFFFFFFFFFFE; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -71571,12 +216613,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3065307\n"); + $fwrite(fp,"2829311\n"); end - x = 64'h302FEFFFFF7FFFFF; - y = 64'h00260D4F5759FE02; - z = 64'h43F000000C000000; - ans = 64'h43F000000C000000; + x = 64'h43CFFF7FDFFFFFFE; + y = 64'h41FFFEFFEFFFFFFF; + z = 64'h4010000000000000; + ans = 64'h45DFFE7FD401400D; rn = 1; rz = 0; rm = 0; @@ -71618,12 +216660,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3067321\n"); + $fwrite(fp,"2829925\n"); end - x = 64'h8000000000000000; - y = 64'h0000000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + x = 64'h7FF0000000000000; + y = 64'h8010000000000000; + z = 64'h46C5C698A716C584; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -71665,12 +216707,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3069335\n"); + $fwrite(fp,"2830539\n"); end - x = 64'hC01E00000000003E; - y = 64'h0010000000000000; - z = 64'h40600001FFFFFFFF; - ans = 64'h40600001FFFFFFFF; + x = 64'hAF408000FFFFFFFE; + y = 64'hBFE00000100007FF; + z = 64'hBFF000001FFFFFFB; + ans = 64'hBFF000001FFFFFFB; rn = 1; rz = 0; rm = 0; @@ -71712,12 +216754,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3071349\n"); + $fwrite(fp,"2831153\n"); end - x = 64'h80200800003FFFFE; - y = 64'h3880008000004000; - z = 64'hA440083FFFFFFFFF; - ans = 64'hA440083FFFFFFFFF; + x = 64'h3F5000000000FEFF; + y = 64'h8010000000000001; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; rn = 1; rz = 0; rm = 0; @@ -71759,10 +216801,2360 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3073363\n"); + $fwrite(fp,"2831767\n"); end - x = 64'h8000000000000000; - y = 64'h3CA0000000000001; + x = 64'h7FF0000000000000; + y = 64'hC3FFFFFFFF801000; + z = 64'h000FFFFFFFDFFC00; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2832381\n"); + end + x = 64'hC35FFF000000003F; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h79300001001FFFFE; + ans = 64'h79300001001FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2832995\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBFF003FE00000000; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2833609\n"); + end + x = 64'h00200000003FFFBE; + y = 64'h41FFFFFFE0000400; + z = 64'h3FC0040000200000; + ans = 64'h3FC0040000200000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2834223\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBCA0000000000001; + z = 64'h8000000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2834837\n"); + end + x = 64'hC340003FFFFFFFFF; + y = 64'hC570000004FFFFFF; + z = 64'h4000000000000001; + ans = 64'h48C00040050013FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2835451\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h801400000000FFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2836065\n"); + end + x = 64'h4584000000000080; + y = 64'h4017FFFFEFFFFFFF; + z = 64'h47FE1280A05363FA; + ans = 64'h47FE1280A05453FA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2836679\n"); + end + x = 64'h00200010000FFFFE; + y = 64'hBFD0000000000000; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2837293\n"); + end + x = 64'h7FF0000000000000; + y = 64'h41C73BE56BB37EBE; + z = 64'hC1DFFFFFFFE7FFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2837907\n"); + end + x = 64'hFFFBF1F5EF2E2892; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC020000102000000; + ans = 64'hFFFBF1F5EF2E2892; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2838521\n"); + end + x = 64'h7FF0000000000000; + y = 64'h801FAAF2E4C19308; + z = 64'hFFE0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2839135\n"); + end + x = 64'hC1D000000003FFFF; + y = 64'h3C4807B2AD0CFCE1; + z = 64'hBFEBD757A7E46DCA; + ans = 64'hBFEBD757A964E8F5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2839749\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBFE0000000000000; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2840363\n"); + end + x = 64'h8A400000007E0000; + y = 64'h400FF8000000FFFE; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2840977\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h40DBFFFFFFFFF7FE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2841591\n"); + end + x = 64'h47FB58DEE3FCB3A6; + y = 64'hC7E000000003FDFE; + z = 64'h4000000000000022; + ans = 64'hCFEB58DEE403866F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2842205\n"); + end + x = 64'hC01FFF0000000001; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h401FFEFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2842819\n"); + end + x = 64'h7FF0000000000000; + y = 64'hB7E24093523AA87A; + z = 64'hC030000040020000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2843433\n"); + end + x = 64'h40354998F7F1DCE5; + y = 64'hBFF0000000000001; + z = 64'hCC1083FFFFFFFFFE; + ans = 64'hCC1083FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2844047\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC24132F19425406D; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2844661\n"); + end + x = 64'h3F8FF7FFFFFF7FFE; + y = 64'h3FD84FD0BC13D2AD; + z = 64'h37FD165AFFD1797D; + ans = 64'h3F7849BCC7E46C78; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2845275\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2845889\n"); + end + x = 64'h40515FAC435403A8; + y = 64'h48FAAF3AB115872C; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h495CF9BE14A322EB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2846503\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC000000000000000; + z = 64'h000FFFE000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2847117\n"); + end + x = 64'hC270000007FFFFC0; + y = 64'hFFFFFFFFFEFFFFFF; + z = 64'hC0102A7E0F9CEE45; + ans = 64'hFFFFFFFFFEFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2847731\n"); + end + x = 64'hB441FFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h3461FFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2848345\n"); + end + x = 64'h7FF0000000000000; + y = 64'hCF52AA0F637D5364; + z = 64'hB8000003FFFEFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2848959\n"); + end + x = 64'h401FDFFFFFFFFFFC; + y = 64'hC010000000000000; + z = 64'hC3DCDE60E50FBCE9; + ans = 64'hC3DCDE60E50FBCE9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2849573\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3FDC2F8EE87082D3; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2850187\n"); + end + x = 64'h402000002000003F; + y = 64'hA8D00FFFFFFFDFFF; + z = 64'h468000FFFFFFEFFE; + ans = 64'h468000FFFFFFEFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2850801\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2851415\n"); + end + x = 64'hBFCC09699F03D2D5; + y = 64'h7FD9D6B397AD3382; + z = 64'h3FE0000000000000; + ans = 64'hFFB6A376D01D6230; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2852029\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h405001FFDFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2852643\n"); + end + x = 64'h4043FFFFFFFFFFFF; + y = 64'h38002D4FB3860015; + z = 64'h3FB0020000000200; + ans = 64'h3FB0020000000200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2853257\n"); + end + x = 64'hB33FFFFFE0000000; + y = 64'hC340000000000001; + z = 64'h8000000000000000; + ans = 64'h368FFFFFE0000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2853871\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC00FFFFFFFF07FFE; + z = 64'h47DFFDFFFFDFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2854485\n"); + end + x = 64'h403FFFFFC000001E; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h41308D4A571E0907; + ans = 64'hC39FFFFFBFFFBDE7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2855099\n"); + end + x = 64'h7FF0000000000000; + y = 64'h400D3244B30A626D; + z = 64'hC010000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2855713\n"); + end + x = 64'hC3DFFFFF001FFFFF; + y = 64'hBF80000002200000; + z = 64'hBCAE00007FFFFFFF; + ans = 64'h436FFFFF045FFFDD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2856327\n"); + end + x = 64'h7FF0000000000000; + y = 64'hFFE0000000000001; + z = 64'h4340000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2856941\n"); + end + x = 64'h407000001FFFF7FF; + y = 64'hC0178722E8E2710F; + z = 64'h3FD0000000000001; + ans = 64'hC097862317F0AB1C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2857555\n"); + end + x = 64'h7FF0000000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h3FB90979A89594A7; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2858169\n"); + end + x = 64'hBE2000000010001F; + y = 64'h3F0000FFFF800000; + z = 64'h402FFFC0000FFFFF; + ans = 64'h402FFFC0000FFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2858783\n"); + end + x = 64'h3F14E7AD5BFBD3E7; + y = 64'hFFF0000000000000; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2859397\n"); + end + x = 64'h7FF0000000000000; + y = 64'h316FFFFFFDFFF7FE; + z = 64'h7FF000000FFFFFF6; + ans = 64'h7FF800000FFFFFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2860011\n"); + end + x = 64'h3CAFFFFFFFFF0040; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h8000003DFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2860625\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC1F8DA003FDA2EDA; + z = 64'hC000000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2861239\n"); + end + x = 64'hC03000000FFFFFBE; + y = 64'h43F0000000040FFF; + z = 64'h47B0000400100000; + ans = 64'h47B0000400100000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2861853\n"); + end + x = 64'h7FF0000000000001; + y = 64'h0000000000000000; + z = 64'h4010000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2862467\n"); + end + x = 64'h36CFBFFFFFFFFFF6; + y = 64'h801FE000000000FE; z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; @@ -71806,12 +219198,623 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3075377\n"); + $fwrite(fp,"2863081\n"); end - x = 64'hC0201FF800000000; + x = 64'h7FF0000000000001; + y = 64'h0000000000000001; + z = 64'h4010100000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2863695\n"); + end + x = 64'hFFF97B52C843D305; + y = 64'h001A888ACADE5D0B; + z = 64'hD8A00080007FFFFF; + ans = 64'hFFF97B52C843D305; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2864309\n"); + end + x = 64'hBFFFFFE000001FFF; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2864923\n"); + end + x = 64'h7FF0000000000001; + y = 64'h3E34C388504B59C2; + z = 64'hA8E00800000003FF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2865537\n"); + end + x = 64'h469114017D84F70F; + y = 64'h0010000000000000; + z = 64'hBFC00000001FFEFE; + ans = 64'hBFC00000001FFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2866151\n"); + end + x = 64'h7FF0000000000001; + y = 64'h43FFFFC3FFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2866765\n"); + end + x = 64'hBE79FFFFFFFFFFFE; + y = 64'h434AD55EDC5984FD; + z = 64'h0023FFFFFFFF7FFE; + ans = 64'hC1D5CD5D1308BC0C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2867379\n"); + end + x = 64'h7FF0000000000001; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2867993\n"); + end + x = 64'h31BF7FFFFFFEFFFF; + y = 64'h41F62EE647FE43C3; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h33C5D62AAEDD993C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2868607\n"); + end + x = 64'h7FF0000000000001; + y = 64'h3CA0000000000000; + z = 64'hBFB01FAF3AFF1ABA; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2869221\n"); + end + x = 64'h3D0000000800FFFF; + y = 64'h41CEFFFFFFBFFFFE; + z = 64'h41D8297E5EAC04D3; + ans = 64'h41D8297E5EAC04F2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2869835\n"); + end + x = 64'h480C000000000002; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h44CC000020000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2870449\n"); + end + x = 64'h7FF0000000000001; + y = 64'hBF8E1FE03410C3CD; + z = 64'hC34001FFFFFFFFFB; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2871063\n"); + end + x = 64'h5240000000000FFD; y = 64'h3CAFFFFFFFFFFFFE; - z = 64'hC0DFFFFFFFF7C000; - ans = 64'hC0DFFFFFFFF7C000; + z = 64'h3FF00FFFFFFFFFDF; + ans = 64'h4F00000000000FFC; rn = 1; rz = 0; rm = 0; @@ -71853,12 +219856,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3077391\n"); + $fwrite(fp,"2871677\n"); end - x = 64'h3FBFFFFFFDFFF7FE; - y = 64'h3FEFFFFFFFFEE000; - z = 64'hBFCFFFFFF801FFFF; - ans = 64'hBFBFFFFFF2052800; + x = 64'h7FF0000000000001; + y = 64'hFFEFFFBFFFFC0000; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h7FF8000000000001; rn = 1; rz = 0; rm = 0; @@ -71900,12 +219903,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3079405\n"); + $fwrite(fp,"2872291\n"); end - x = 64'h8000000000000000; - y = 64'h3FE0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; + x = 64'hF8A0000002001FFF; + y = 64'h43DFFFFF00000002; + z = 64'hC34FFFFE00001FFF; + ans = 64'hFC8FFFFF04003FE0; rn = 1; rz = 0; rm = 0; @@ -71947,12 +219950,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3081419\n"); + $fwrite(fp,"2872905\n"); end - x = 64'hB8000FFFFFFFFFFB; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'hFFF03FFFF7FFFFFE; - ans = 64'hFFF83FFFF7FFFFFE; + x = 64'h7FF0000000000001; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h7FF8000000000001; rn = 1; rz = 0; rm = 0; @@ -71994,12 +219997,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3083433\n"); + $fwrite(fp,"2873519\n"); end - x = 64'hB54000000003FFFF; - y = 64'hBFD1000FFFFFFFFE; - z = 64'h3FD00000000005FF; - ans = 64'h3FD00000000005FF; + x = 64'hBFF00000800003FF; + y = 64'h60F0400000080000; + z = 64'h0010000000000000; + ans = 64'hE0F040008208040F; rn = 1; rz = 0; rm = 0; @@ -72041,10 +220044,104 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3085447\n"); + $fwrite(fp,"2874133\n"); end - x = 64'h8000000000000000; - y = 64'h4000000000000000; + x = 64'h7FF0000000000001; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h41DFFFFFEEFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2874747\n"); + end + x = 64'h3CA27F59AF996B9F; + y = 64'h4D6FFFFFFFFF7FFE; + z = 64'h1F9FFFFFFFDEFFFF; + ans = 64'h4A227F59AF9921A0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2875361\n"); + end + x = 64'hBF9FFFFFFFE00002; + y = 64'h3FE0000000000001; z = 64'h4340000000000000; ans = 64'h4340000000000000; rn = 1; @@ -72088,12 +220185,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3087461\n"); + $fwrite(fp,"2875975\n"); end - x = 64'hC21103FFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFF; - z = 64'hC3E0200FFFFFFFFE; - ans = 64'hC3E0201002207FFE; + x = 64'h7FF0000000000001; + y = 64'hC1FFFFFC0007FFFE; + z = 64'hBFEFFEFFFFFFFFBF; + ans = 64'h7FF8000000000001; rn = 1; rz = 0; rm = 0; @@ -72135,12 +220232,16415 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3089475\n"); + $fwrite(fp,"2876589\n"); end - x = 64'hBFB00207FFFFFFFE; - y = 64'hC1F80BD9803691DC; - z = 64'hC3F000200000007E; - ans = 64'hC3F0001FFFFE7F90; + x = 64'h3F7FBFFFFFE00000; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3817BF5A3F991426; + ans = 64'h3F7FBFFFFFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2877203\n"); + end + x = 64'h7FF0000000000001; + y = 64'h4FF2AD354C273C4F; + z = 64'hBFE0000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2877817\n"); + end + x = 64'h45AFFFFFFFDEFFFF; + y = 64'hBC3DFFFFFFFFFFEF; + z = 64'h800FF7FFFFFFFFFB; + ans = 64'hC1FDFFFFFFE10FEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2878431\n"); + end + x = 64'h7FF0000000000001; + y = 64'h3FF0000000000001; + z = 64'h3FF0000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2879045\n"); + end + x = 64'hBFD000000100000F; + y = 64'hC09A69FA93AE1A05; + z = 64'h0000000000000001; + ans = 64'h407A69FA9554B9C7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2879659\n"); + end + x = 64'h7FF0000000000001; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC7E10C2C8E90FC29; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2880273\n"); + end + x = 64'h646FFFFFFFEFFF7F; + y = 64'hC203FEEF05195503; + z = 64'hC010000FFFFFFFDE; + ans = 64'hE683FEEF050F553B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2880887\n"); + end + x = 64'h42E8000000080000; + y = 64'h4000000000000000; + z = 64'h4010000000000001; + ans = 64'h42F8000000080040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2881501\n"); + end + x = 64'h7FF0000000000001; + y = 64'h800138DCFF1B5E8A; + z = 64'hFFEFFFFFDFFFDFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2882115\n"); + end + x = 64'hC1DFFFFFFFFFFFFF; + y = 64'h4000000000000001; + z = 64'h41FF000000001FFF; + ans = 64'h41EE000000003FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2882729\n"); + end + x = 64'h7FF0000000000001; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hBFD0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2883343\n"); + end + x = 64'h3FFC50269594D1EA; + y = 64'h80100000000FFFBF; + z = 64'hC3C5A4DEA80A7E9C; + ans = 64'hC3C5A4DEA80A7E9C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2883957\n"); + end + x = 64'h7FF0000000000001; + y = 64'h4010000000000000; + z = 64'h3FE0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2884571\n"); + end + x = 64'h9210003FFFFFFFEF; + y = 64'hBFCFFFFFFFFFFFCF; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2885185\n"); + end + x = 64'h7FF0000000000001; + y = 64'h4010000000000001; + z = 64'h380FFFFFFC00001F; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2885799\n"); + end + x = 64'h3FE000000002FFFE; + y = 64'hBF6040FFFFFFFFFF; + z = 64'hBFEFFF0001FFFFFF; + ans = 64'hBFF00390410000C3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2886413\n"); + end + x = 64'h3F1FFFFFFF7FBFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h401000FFFFFFFBFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2887027\n"); + end + x = 64'h7FF0000000000001; + y = 64'hAD0FFFBFFFFFFFFF; + z = 64'hC1C30CFDF166F3A9; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2887641\n"); + end + x = 64'hBFC88F53F742F741; + y = 64'h4340000000000000; + z = 64'hBCADA4273450D0D3; + ans = 64'hC3188F53F742F741; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2888255\n"); + end + x = 64'h7FF0000000000001; + y = 64'h4020000000FFDFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2888869\n"); + end + x = 64'h3FF00040000000FF; + y = 64'h41DFFFFFFFFFFE02; + z = 64'hAB00000000012000; + ans = 64'h41E0004000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2889483\n"); + end + x = 64'h7FF0000000000001; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2890097\n"); + end + x = 64'hC7E003FFFDFFFFFF; + y = 64'hB97BF69F52A53CD4; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2890711\n"); + end + x = 64'h7FF0000000000001; + y = 64'h7FE0000000000000; + z = 64'hC010000000006FFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2891325\n"); + end + x = 64'h420FFFFFFFE07FFF; + y = 64'h002FFF7FFFFFFFFB; + z = 64'hC01FFF3FFFFFFFFF; + ans = 64'hC01FFF3FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2891939\n"); + end + x = 64'h43BAE28442A43690; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2892553\n"); + end + x = 64'h7FF0000000000001; + y = 64'h47E90072420C8EAB; + z = 64'hC3C2000001000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2893167\n"); + end + x = 64'hBFE0000003FFFFDF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hB0E0801FFFFFFFFF; + ans = 64'hFFE0000003FFFFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2893781\n"); + end + x = 64'h7FF0000000000001; + y = 64'hFFDFFFFFFFEFFFF7; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2894395\n"); + end + x = 64'hBFCF7FFFFFFF0000; + y = 64'hC01AB4C668B81BFF; + z = 64'hCCC7FFFFFFFFFBFE; + ans = 64'hCCC7FFFFFFFFFBFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2895009\n"); + end + x = 64'h7FF0000000000001; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2895623\n"); + end + x = 64'hC02FE01000000000; + y = 64'hC6DFFFFDFFFFFFFD; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2896237\n"); + end + x = 64'h7FF0000000000001; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hBFD0080000200000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2896851\n"); + end + x = 64'hB7E0000000FFFFDE; + y = 64'hC8000040FFFFFFFF; + z = 64'h3CA25A25EB808CF6; + ans = 64'h3FF00041010003EE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2897465\n"); + end + x = 64'h600FFFFFFFFFC002; + y = 64'h8000000000000001; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2898079\n"); + end + x = 64'h7FF0000000000001; + y = 64'h400000000000002F; + z = 64'h380DF17822F732BD; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2898693\n"); + end + x = 64'hB11AD0B8DA26800D; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC780000000000017; + ans = 64'hC780000000000017; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2899307\n"); + end + x = 64'h7FF0000000000001; + y = 64'h400E791D9DD9BC2F; + z = 64'h8010000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2899921\n"); + end + x = 64'h81A0000FBFFFFFFF; + y = 64'h4343FFFFFFFFFF7E; + z = 64'h401FFF800000007E; + ans = 64'h401FFF800000007E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2900535\n"); + end + x = 64'h7FF0000000000001; + y = 64'h8010000000000001; + z = 64'h3CA0000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2901149\n"); + end + x = 64'h4D8000004000007F; + y = 64'hBF60000010000001; + z = 64'hC340000000000001; + ans = 64'hCCF00000500000C0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2901763\n"); + end + x = 64'h7FF0000000000001; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h3DA00000002001FF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2902377\n"); + end + x = 64'h3FDFFFE00000FFFE; + y = 64'h5B962D44BC128284; + z = 64'hC1F37FD701772207; + ans = 64'h5B862D2E8ECE77DA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2902991\n"); + end + x = 64'h480F000000000006; + y = 64'hBCA0000000000000; + z = 64'h3FE0000000000001; + ans = 64'hC4BF000000000006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2903605\n"); + end + x = 64'h7FF0000000000001; + y = 64'hC1F17FFFFFFFFFFF; + z = 64'hC02041FFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2904219\n"); + end + x = 64'h4028629AD7424975; + y = 64'hBCA0000000000001; + z = 64'h3CA00001FFFFFC00; + ans = 64'hBCD6629A974249F7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2904833\n"); + end + x = 64'h7FF0000000000001; + y = 64'hC1DFFFFFFE000200; + z = 64'h8000000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2905447\n"); + end + x = 64'hBFDF00000001FFFF; + y = 64'hC80FFFFFFFFFFDBF; + z = 64'hC7B978FC409BA3FD; + ans = 64'h47FD68703BF84390; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2906061\n"); + end + x = 64'h7FF0000000000001; + y = 64'hBFD0000000000000; + z = 64'h0010000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2906675\n"); + end + x = 64'hC1ED805BD15C139B; + y = 64'h28901FFFFFFFFFFD; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2907289\n"); + end + x = 64'h7FF0000000000001; + y = 64'hBFD0000000000001; + z = 64'h4030000800200000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2907903\n"); + end + x = 64'h37EFFFFFBC000000; + y = 64'hF040000200000FFF; + z = 64'hBFAFFFFFF7FEFFFE; + ans = 64'hE8400001DE000BBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2908517\n"); + end + x = 64'hBFFFFFF5FFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FF7FFFAFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2909131\n"); + end + x = 64'h7FF0000000000001; + y = 64'h40200000FFFFDFFE; + z = 64'hAC4F7052B43B96D6; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2909745\n"); + end + x = 64'hC3FC000040000000; + y = 64'hBFE0000000000000; + z = 64'hBF9FFFFFBFFFFBFF; + ans = 64'h43EC000040000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2910359\n"); + end + x = 64'h7FF0000000000001; + y = 64'h3CA00003FFFFFFF6; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2910973\n"); + end + x = 64'h39CEA5268438722C; + y = 64'h3E4FDFFDFFFFFFFF; + z = 64'h3FE0000000FFFFFC; + ans = 64'h3FE0000000FFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2911587\n"); + end + x = 64'h7FF0000000000001; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2912201\n"); + end + x = 64'h802FFFC000003FFF; + y = 64'h3D700000000FFFF8; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2912815\n"); + end + x = 64'h7FF0000000000001; + y = 64'hBFF0000000000000; + z = 64'h3FBF00000000001F; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2913429\n"); + end + x = 64'h47E03FFFFFFFF800; + y = 64'hC00001007FFFFFFF; + z = 64'h400000000008001E; + ans = 64'hC7F0410481FFF7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2914043\n"); + end + x = 64'h38100003FEFFFFFF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2914657\n"); + end + x = 64'h7FF0000000000001; + y = 64'h5EBDA64B1F6C454A; + z = 64'hBFE000000800001F; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2915271\n"); + end + x = 64'h41FFDFFFFF7FFFFE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBC639470CFAB75A4; + ans = 64'hC20FDFFFFF7FFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2915885\n"); + end + x = 64'h7FF0000000000001; + y = 64'hBFF83A1ED571DC64; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2916499\n"); + end + x = 64'h802000004000FFFF; + y = 64'hC00010003FFFFFFE; + z = 64'h80110003FFFFFFFE; + ans = 64'h00279FFF008203FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2917113\n"); + end + x = 64'h7FF0000000000001; + y = 64'hC000000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2917727\n"); + end + x = 64'hFFEFFFFFFFFFF01F; + y = 64'h3FDDF7FFFFFFFFFE; + z = 64'hC000000000000000; + ans = 64'hFFDDF7FFFFFFF11F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2918341\n"); + end + x = 64'h7FF0000000000001; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBF8F7FFFFFFFFFBF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2918955\n"); + end + x = 64'hC024C21357A48D0D; + y = 64'hFFF0000000003FF7; + z = 64'h41D00017FFFFFFFE; + ans = 64'hFFF8000000003FF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2919569\n"); + end + x = 64'h445169266A3DEB8C; + y = 64'hC010000000000001; + z = 64'h3CA0000000000000; + ans = 64'hC47169266A3DEB8D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2920183\n"); + end + x = 64'h7FF0000000000001; + y = 64'h7FDFFF000007FFFF; + z = 64'hBFCFFFFFFFFF800E; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2920797\n"); + end + x = 64'h43DFFF83FFFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h41E0007FFF000000; + ans = 64'hC40FFF83FFFBFFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2921411\n"); + end + x = 64'h7FF0000000000001; + y = 64'h47EFFFFFFFF7FFFE; + z = 64'h7FE0000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2922025\n"); + end + x = 64'h3E400001FFFBFFFF; + y = 64'h3FE77A2166CACFDC; + z = 64'h381359BB509306FE; + ans = 64'h3E377A2456091E2C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2922639\n"); + end + x = 64'h7FF0000000000001; + y = 64'hC340000000000000; + z = 64'hFFF0000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2923253\n"); + end + x = 64'hBFD000000004007F; + y = 64'h3FDFFFFBFFFFFBFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF1FFFFC0007FD1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2923867\n"); + end + x = 64'h7FF0000000000001; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h3CACE893AA2E59D8; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2924481\n"); + end + x = 64'h3FB0B636B6EA69D3; + y = 64'h2600000007FFFFBE; + z = 64'h3601FFFFFFFFFF7F; + ans = 64'h3601FFFFFFFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2925095\n"); + end + x = 64'hC550000080000FFF; + y = 64'hFFE0000000000000; + z = 64'h0010000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2925709\n"); + end + x = 64'h7FF0000000000001; + y = 64'h43FFFFFFF000001E; + z = 64'h3FF0400200000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2926323\n"); + end + x = 64'h41EFFFFFFC000001; + y = 64'hFFE0000000000001; + z = 64'h407FC00000000007; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2926937\n"); + end + x = 64'h7FF0000000000001; + y = 64'h46452C93D5A9BE1B; + z = 64'h4340000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2927551\n"); + end + x = 64'h3FA4BFCB07A2886E; + y = 64'h3B1F43C73803FA4C; + z = 64'h3FB200FFFFFFFFFF; + ans = 64'h3FB200FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2928165\n"); + end + x = 64'h7FF0000000000001; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hFFE0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2928779\n"); + end + x = 64'h20BFFFFF7EFFFFFE; + y = 64'h43DFFFE000000100; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2929393\n"); + end + x = 64'h7FF0000000000001; + y = 64'hFFF0000000000001; + z = 64'hC7E0000001FFFFEF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2930007\n"); + end + x = 64'h400D2E087C272421; + y = 64'h58200401FFFFFFFE; + z = 64'hC3C266610B3228BB; + ans = 64'h583D3557A4073D6B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2930621\n"); + end + x = 64'h47EEFFFFFFBFFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2931235\n"); + end + x = 64'h7FF0000000000001; + y = 64'hC054A510735203C8; + z = 64'hC3EFFFFFFFFE01FF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2931849\n"); + end + x = 64'hC34000001FFFFDFF; + y = 64'h0000000000000000; + z = 64'h7FE0000000011FFF; + ans = 64'h7FE0000000011FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2932463\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBFEFFFFF7FFFFFFE; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2933077\n"); + end + x = 64'h1440D7A99B79C195; + y = 64'h3D6000000000100F; + z = 64'hC3DFF800007FFFFF; + ans = 64'hC3DFF800007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2933691\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2934305\n"); + end + x = 64'hBFC72574439F0F8D; + y = 64'hBCCE99A34A3E0638; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2934919\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h0010000000000000; + z = 64'hC1DF000000000FFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2935533\n"); + end + x = 64'h801FFFFFFBFFFFEF; + y = 64'hC340440000000000; + z = 64'h40808FFFFFFFFFFE; + ans = 64'h40808FFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2936147\n"); + end + x = 64'hBFF60F1DF5DA594A; + y = 64'h0010000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2936761\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3FE0000000110000; + z = 64'h3FCFFFFFFFFDFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2937375\n"); + end + x = 64'hBB212651C58F296A; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h7FD3E0DB33B0C462; + ans = 64'h7FD3E0DB33B0C462; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2937989\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h43C0000000001EFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2938603\n"); + end + x = 64'h402AFC152BB76278; + y = 64'hC73F7FFFFFFEFFFF; + z = 64'hBDD0000080FFFFFF; + ans = 64'hC77A9024D707AD0D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2939217\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3CA0000000000001; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2939831\n"); + end + x = 64'h3CF0100FFFFFFFFE; + y = 64'h3E5FDFFF7FFFFFFE; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2940445\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h7FDFFFFE04000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2941059\n"); + end + x = 64'hC3CFCFFFFFFFFFFF; + y = 64'h4043FFFFFFFFBFFF; + z = 64'hC010003FFFFFFFFE; + ans = 64'hC423E1FFFFFFC05E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2941673\n"); + end + x = 64'hC1E499D3794E5EF8; + y = 64'h3FD0000000000000; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2942287\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3F0000000080FFFF; + z = 64'h7FF000000F7FFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2942901\n"); + end + x = 64'h41EFFFFFFFFEFF7F; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h480F7FC000000000; + ans = 64'h480F7FC000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2943515\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC426783221EF473C; + z = 64'h4000000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2944129\n"); + end + x = 64'h7FE01FFFFFFFDFFF; + y = 64'h434FFFF00001FFFE; + z = 64'h381FF7FFFFF7FFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2944743\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3FE0000000000000; + z = 64'hC010000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2945357\n"); + end + x = 64'hF3ABFFF7FFFFFFFF; + y = 64'hBD5EFFBFFFFFFFFE; + z = 64'hBCA0000000000001; + ans = 64'h711B1FC0400FFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2945971\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h434FFFFEFFFFFFFD; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2946585\n"); + end + x = 64'hBFA0000001FFF7FF; + y = 64'h3E32C8772CF7A110; + z = 64'hC150004000200000; + ans = 64'hC150004000200000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2947199\n"); + end + x = 64'hC6BFFFFDFFBFFFFE; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2947813\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h407BE20CE424F639; + z = 64'h2380003FFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2948427\n"); + end + x = 64'h4E4FFF7FFFEFFFFF; + y = 64'h3FF0000000000001; + z = 64'h4000000000101000; + ans = 64'h4E4FFF7FFFF00001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2949041\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFF01FF; + z = 64'h3FF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2949655\n"); + end + x = 64'h403FFBFFFFFFFDFF; + y = 64'hFCAF4DA8CA8EDCB6; + z = 64'h3FFFFFFFFFEFFFBF; + ans = 64'hFCFF49BF157588E5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2950269\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC000000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2950883\n"); + end + x = 64'hBFD0000007FF7FFF; + y = 64'hFFDFFFEFFFFFFFEF; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h7FBFFFF00FFEF7EE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2951497\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h4000000000000001; + z = 64'h3FEFFFFFFBEFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2952111\n"); + end + x = 64'hF6C7FBFFFFFFFFFE; + y = 64'h3F0FF80000200000; + z = 64'h38200000000008FE; + ans = 64'hF5E7F6010017FBFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2952725\n"); + end + x = 64'hC01FF003FFFFFFFE; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC350000000000007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2953339\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBCA8A69E52F6A7C2; + z = 64'h3FE0002000FFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2953953\n"); + end + x = 64'hC670003BFFFFFFFF; + y = 64'h4010000000000000; + z = 64'h3F4000008FFFFFFF; + ans = 64'hC690003BFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2954567\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBFCBFFFFFFFFFFFE; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2955181\n"); + end + x = 64'h2E85F2326ACAC7CD; + y = 64'h40200000100000FF; + z = 64'h390000001FFFC000; + ans = 64'h390000001FFFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2955795\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2956409\n"); + end + x = 64'hC7F0005FFFFFFFFE; + y = 64'h001FFFFFDFFFEFFF; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h8820005FEFFF97FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2957023\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h4340000000000000; + z = 64'hBFF587068DC3E0AA; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2957637\n"); + end + x = 64'hB9FFF4E99D3A4249; + y = 64'hF4D0007FFBFFFFFF; + z = 64'h402000000000083E; + ans = 64'h6EDFF5E93C89F1B2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2958251\n"); + end + x = 64'hE2A0000041FFFFFF; + y = 64'h4340000000000001; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hE5F0000042000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2958865\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h7FFBCB3137A93FEB; + z = 64'hBFEFFFF8001FFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2959479\n"); + end + x = 64'h37FFFFFFFFFBFFBE; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h41FFFFFFFFFDFFF7; + ans = 64'h41FFFFFFFFFDFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2960093\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3DCC0000FFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2960707\n"); + end + x = 64'h3ED4000000040000; + y = 64'h47F0000000006FFF; + z = 64'hBFE26C979F9A687F; + ans = 64'h46D4000000048BFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2961321\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h7FE0000000000001; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2961935\n"); + end + x = 64'hC390000001000000; + y = 64'h74AAA02E49FFE7E3; + z = 64'h8000000000000000; + ans = 64'hF84AA02E4BA9EAC8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2962549\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h5D7000001000007F; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2963163\n"); + end + x = 64'hC0200007FFFFFDFF; + y = 64'h40036DCAC049B7DE; + z = 64'h43D2000001FFFFFF; + ans = 64'h43D2000001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2963777\n"); + end + x = 64'hE93FFE0000000002; + y = 64'h7FF0000000000000; + z = 64'hC010000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2964391\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h531002FFFFFFFFFF; + z = 64'hA74FF7F000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2965005\n"); + end + x = 64'h47EFFFC000000002; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hC150000020040000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2965619\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFE3FF; + z = 64'h3FD0000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2966233\n"); + end + x = 64'hC3DBE28DD099AC7E; + y = 64'h407FFFFFFFFFFFFE; + z = 64'h37FFFE0000FFFFFE; + ans = 64'hC46BE28DD099AC7C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2966847\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h8000000000000000; + z = 64'hBFE0000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2967461\n"); + end + x = 64'h41D000000000001D; + y = 64'h3EFFFEBFFFFFFFFF; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2968075\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC030000003FFF7FF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2968689\n"); + end + x = 64'hCCD1FFFFFFFFF7FF; + y = 64'h47B00000DFFFFFFF; + z = 64'hC03000000001000E; + ans = 64'hD4920000FBFFF7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2969303\n"); + end + x = 64'h3807FFFF7FFFFFFE; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2969917\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hCC3FFFFFFFFFFBEF; + z = 64'hCF4FFFFFFFFC0008; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2970531\n"); + end + x = 64'h480FFFC000000200; + y = 64'h8010000000000001; + z = 64'hBD11000000000001; + ans = 64'hBD11000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2971145\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC0B16FFAF4B669F3; + z = 64'h3CA0000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2971759\n"); + end + x = 64'hABFFFEFFFC000000; + y = 64'hBDD000008000007F; + z = 64'hC0EFFD0000000000; + ans = 64'hC0EFFD0000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2972373\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBFD0000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2972987\n"); + end + x = 64'h41CFE0000FFFFFFF; + y = 64'h7FFE000003FFFFFF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FFE000003FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2973601\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBCA0000000000001; + z = 64'hC00800001FFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2974215\n"); + end + x = 64'hBCABFBFFFFFFFFFF; + y = 64'h3FF087050E4FE191; + z = 64'h3FC0000024000000; + ans = 64'h3FC0000023FFFFF9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2974829\n"); + end + x = 64'h0149F402042DF1CE; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2975443\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFEEF; + z = 64'h41FD601EC095C9B3; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2976057\n"); + end + x = 64'h41D3E7CF94A31274; + y = 64'hBFD0000000000000; + z = 64'h3FB000000FFBFFFF; + ans = 64'hC1B3E7CF94931274; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2976671\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hB81F800000100000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2977285\n"); + end + x = 64'hC1C00001FFFFFBFE; + y = 64'hB7FFFFFFFFFFB800; + z = 64'hC448000000001FFF; + ans = 64'hC448000000001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2977899\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2978513\n"); + end + x = 64'h3FFFEFFFFE000000; + y = 64'hC7F76493330323AA; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'hC80758E0E7F358E5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2979127\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBFE0000000000000; + z = 64'h47EFFFE000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2979741\n"); + end + x = 64'hEFF00000000077FF; + y = 64'hBADBE97EB9C9AE4B; + z = 64'h3817B654678C79D0; + ans = 64'h6ADBE97EB9CA7FA0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2980355\n"); + end + x = 64'hC2A4F3FF01FF246C; + y = 64'hBFE0000000000001; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h4294F3FF01FF206D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2980969\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h43FFFFC0000000FF; + z = 64'h41D0000000003FFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2981583\n"); + end + x = 64'h52FCE5A153E7E2E9; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFE7FFF; + ans = 64'hD2FCE5A153E7E2E7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2982197\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hA8527BA8C2664DC8; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2982811\n"); + end + x = 64'hC01D3A4BBE35A328; + y = 64'h380FFFBFFFFFFFDE; + z = 64'h3FD8000080000000; + ans = 64'h3FD8000080000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2983425\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBFF0000000000001; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2984039\n"); + end + x = 64'h4E3FFFFFFEFFFF00; + y = 64'h55E0007F7FFFFFFF; + z = 64'h4340000000000000; + ans = 64'h6430007F7F7FFB83; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2984653\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBFD0003FFBFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2985267\n"); + end + x = 64'h3800000000000006; + y = 64'hC7EFF00000001FFE; + z = 64'hBCA0000001FFFFFF; + ans = 64'hBFFFF0000000200A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2985881\n"); + end + x = 64'hBC5FFFFFFFFE0800; + y = 64'hC000000000000000; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2986495\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC05FFFFFFFDFFFF7; + z = 64'h403FBFFFFFFDFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2987109\n"); + end + x = 64'hC56E00AC42169CC5; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h47E0004000001FFF; + ans = 64'h47E0004000009802; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2987723\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC0100003FFFFFFDF; + z = 64'h0000000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2988337\n"); + end + x = 64'hBF6FFC8000000000; + y = 64'h3B4FFFFBFFFBFFFF; + z = 64'h41FB680E63FF69F2; + ans = 64'h41FB680E63FF69F2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2988951\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC010000000000000; + z = 64'h8010000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2989565\n"); + end + x = 64'h7FF4000003FFFFFF; + y = 64'h80007FFFFFFFFFFD; + z = 64'h4010000000000001; + ans = 64'h7FFC000003FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2990179\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hC3C2415F61A098C3; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2990793\n"); + end + x = 64'h3F9047FFFFFFFFFF; + y = 64'hC1E00000008000FE; + z = 64'hBF9EFFF7FFFFFFFF; + ans = 64'hC180480000C040F1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2991407\n"); + end + x = 64'hC8501000003FFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBFD0000000000001; + ans = 64'h48801000003FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2992021\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3810000020000007; + z = 64'h3FE47701E81BB120; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2992635\n"); + end + x = 64'hBCAFF7FFFFFFFFFF; + y = 64'hC340000000000001; + z = 64'h3FF003FFFFFFFFEF; + ans = 64'h4007FDFFFFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2993249\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC020000000000104; + z = 64'hFFF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2993863\n"); + end + x = 64'hC710000000001800; + y = 64'h666FFE00000001FF; + z = 64'hB8E000FFBFFFFFFF; + ans = 64'hED8FFE00000031FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2994477\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h8000000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2995091\n"); + end + x = 64'h4011FFFFDFFFFFFF; + y = 64'hBFEF9C08BE85F180; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'hBFDC7C4CB8F4F190; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2995705\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hFFE0000000000001; + z = 64'h4B9000000007C000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2996319\n"); + end + x = 64'h407000010001FFFF; + y = 64'h40059E6C85575EAA; + z = 64'h2ED13DD9EC8C1C60; + ans = 64'h40859E6DDF40DACC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2996933\n"); + end + x = 64'h39FFFFFFFC00000E; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hF9FFFFFFFC00000D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2997547\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h47F1FFFFFFFFFDFE; + z = 64'h421FFFDDFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2998161\n"); + end + x = 64'h7FDFC02000000000; + y = 64'hFFF0000000000000; + z = 64'h434367E1A214D062; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2998775\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBB30000000400020; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2999389\n"); + end + x = 64'h3FC231C33927C327; + y = 64'h024000008000003F; + z = 64'h43CFFFFE1FFFFFFF; + ans = 64'h43CFFFFE1FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3000003\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3000617\n"); + end + x = 64'hCB0020000000007E; + y = 64'hAEEFFFFFFFFFFFBE; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3001231\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h0000000000000000; + z = 64'h41C07FFFFFFFFEFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3001845\n"); + end + x = 64'hC36FFFFFFFFE3FFF; + y = 64'h43400000003FF7FF; + z = 64'h4D21F9255625574B; + ans = 64'h4D21F9255625574B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3002459\n"); + end + x = 64'hFD61DD32FB8E3B2C; + y = 64'h0000000000000001; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hBA41DD32FB8E3B2C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3003073\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h3EB6CDE6B789E903; + z = 64'hBFB00000001FFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3003687\n"); + end + x = 64'hBFD000000000021F; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hBCFFFFFBFFFEFFFF; + ans = 64'hBCFFFFFBFFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3004301\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h401FFFFFBFC00000; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3004915\n"); + end + x = 64'h42100FFFFFF80000; + y = 64'h404000000100003F; + z = 64'h6E800003FFFE0000; + ans = 64'h6E800003FFFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3005529\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h0010000000000001; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3006143\n"); + end + x = 64'hC7EFFFFFFFF7FFFF; + y = 64'h1BD000FBFFFFFFFE; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3006757\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hBFF0000000000017; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3007371\n"); + end + x = 64'hC02FFFFFFFBFFEFE; + y = 64'hFFE000007FF7FFFF; + z = 64'hC800008000000400; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3007985\n"); + end + x = 64'h3DFFFF7FFEFFFFFF; + y = 64'h3CA0000000000000; + z = 64'h8010000000000000; + ans = 64'h3AAFFF7FFEFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3008599\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBCAFFFFFDFDFFFFF; + z = 64'hC00FFFDFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3009213\n"); + end + x = 64'h3FCFFFFFFFFFEEFE; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hBE8FFFFFF01FFFFF; + ans = 64'hBE8FFFFFEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3009827\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h4D70000000040020; + z = 64'hC340000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3010441\n"); + end + x = 64'h4804036E90673318; + y = 64'hC490001000000010; + z = 64'hBFC0000002FFFFFE; + ans = 64'hCCA4038293D5C393; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3011055\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h3FD0000000000000; + z = 64'h7FE0000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3011669\n"); + end + x = 64'h37EFFFFFFFF0001F; + y = 64'hFFDF23B774D41560; + z = 64'h3FE0000000000001; + ans = 64'hF7DF23B774C483A2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3012283\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h3FD0000000000001; + z = 64'hC02EFFFFFFFDFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3012897\n"); + end + x = 64'h0010000008000100; + y = 64'h384000007FFF0000; + z = 64'h43D7FFFFFFFFF7FF; + ans = 64'h43D7FFFFFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3013511\n"); + end + x = 64'h3418CAE9C47A6455; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h8000000000000001; + ans = 64'h3408CAE9C47A6453; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3014125\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h41DC1D360A4CE088; + z = 64'h47F396D52218D15D; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3014739\n"); + end + x = 64'h406FF800000FFFFF; + y = 64'h3FE0000000000001; + z = 64'h3FFFF8000000007E; + ans = 64'h40603BF000080001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3015353\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h37EFFFFFFFFFFFFF; + z = 64'hC010000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3015967\n"); + end + x = 64'h40BFFBFFFFBFFFFF; + y = 64'h417DE0C0C0105BC4; + z = 64'h3F9FFFFFDFFFFEFF; + ans = 64'h424DDD04A7BC9C36; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3016581\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h4340000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3017195\n"); + end + x = 64'h00101FFFFFFBFFFF; + y = 64'h0F653D345B988780; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3017809\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h3FF0000000000000; + z = 64'hBFC0000080004000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3018423\n"); + end + x = 64'hC3D00000000FBFFF; + y = 64'hC03FFFFFFFB7FFFE; + z = 64'h37EF000000000000; + ans = 64'h441FFFFFFFD77FFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3019037\n"); + end + x = 64'hC18FFFFF8001FFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3019651\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBFC000001FFFFFE0; + z = 64'h37E0000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3020265\n"); + end + x = 64'h3FF7FFF7FFFFFFFE; + y = 64'h4000000000000000; + z = 64'h4340001000000800; + ans = 64'h4340001000000801; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3020879\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBE1202812D66086A; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3021493\n"); + end + x = 64'hC01BDC176961CDDF; + y = 64'h41EFFFFFFBFFEFFF; + z = 64'h29C00021FFFFFFFF; + ans = 64'hC21BDC1765E63D03; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3022107\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3022721\n"); + end + x = 64'h41C000003FFEFFFF; + y = 64'hC7FFFFFC003FFFFE; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'hC9CFFFFC803DEFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3023335\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h41E007FFF7FFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3023949\n"); + end + x = 64'h9CDFFFFF8003FFFF; + y = 64'hC3CFFFF7FFFFFFFF; + z = 64'h41D000011FFFFFFF; + ans = 64'h41D000011FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3024563\n"); + end + x = 64'h40BFFFFFFFFF9FFF; + y = 64'h4010000000000001; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3025177\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h41F00080FFFFFFFF; + z = 64'h3FE00000000043FE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3025791\n"); + end + x = 64'hC0116A3A0E8BD9D8; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3FD0000007FFFFF0; + ans = 64'hC0414A3A0E7BD9D8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3026405\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hD26FFE3FFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3027019\n"); + end + x = 64'h402FFFFFFFDFFFFC; + y = 64'hBC1A0EF14D39976E; + z = 64'hC0776D17463EB959; + ans = 64'hC0776D17463EB959; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3027633\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h4340000000000001; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3028247\n"); + end + x = 64'hC800003FFFFFF7FF; + y = 64'hBFBFFFDFF7FFFFFE; + z = 64'h3CA0000000000000; + ans = 64'h47D0002FFBBFE7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3028861\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h41DE8439E1A9A3DA; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3029475\n"); + end + x = 64'hFFDF39CFA8A03BE2; + y = 64'hC3D000000040003E; + z = 64'h400C000000000800; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3030089\n"); + end + x = 64'h37E003EFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3030703\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hC04FFE000007FFFF; + z = 64'hBD8EFFFFFFFFFFDF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3031317\n"); + end + x = 64'h7FE173412B78E0FE; + y = 64'h7FE0000000000001; + z = 64'h43AFFFFFF7FFF000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3031931\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h4316F79517C28E75; + z = 64'hBFF0000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3032545\n"); + end + x = 64'hC02200000000003F; + y = 64'h4010007FFFFFFFFF; + z = 64'hB8100001FFFFFF00; + ans = 64'hC04200900000003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3033159\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h7FF0000000000000; + z = 64'h4000000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3033773\n"); + end + x = 64'hC5CC79F66E8517AD; + y = 64'h3DAFBFFFFFFFFFDE; + z = 64'h0010000000000001; + ans = 64'hC38C410281A80D5F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3034387\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h7FF0000000000001; + z = 64'h7FD0D5BD4FCDC113; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3035001\n"); + end + x = 64'hAC400001000FFFFE; + y = 64'hC00FFFFFE0003FFE; + z = 64'h3FDFFEFFFFFFFFFD; + ans = 64'h3FDFFEFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3035615\n"); + end + x = 64'h40BFFFFF0000003F; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h4340000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3036229\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hFFDFFFFFEFFFFFFF; + z = 64'hBC157D122DBD3C91; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3036843\n"); + end + x = 64'h409FFC0000000002; + y = 64'h8000000000000000; + z = 64'hB8020D0B3462BA3F; + ans = 64'hB8020D0B3462BA3F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3037457\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h40B0004003FFFFFF; + z = 64'hBFE0000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3038071\n"); + end + x = 64'h4030FBFFFFFFFFFF; + y = 64'h40A8000000000010; + z = 64'h6560001FFC000000; + ans = 64'h6560001FFC000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3038685\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3039299\n"); + end + x = 64'hBFC0000000000002; + y = 64'h400FFFF80000000F; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hBFDFFFF800000013; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3039913\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h8010000000000000; + z = 64'hBF497D946A140E35; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3040527\n"); + end + x = 64'h3FCFFFFFC8000000; + y = 64'h40429DE6F85FE585; + z = 64'hBD33E8B29443F848; + ans = 64'h40229DE6D7CB912B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3041141\n"); + end + x = 64'hC0004000000003FF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3041755\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h1ED0088000000000; + z = 64'h43C0004000000800; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3042369\n"); + end + x = 64'h801000FFDFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFBEFE; + ans = 64'hBCAFFFFFFFFFBEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3042983\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hC5AFFEFFFFFEFFFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3043597\n"); + end + x = 64'h43CC000000008000; + y = 64'hBF9FEFFFFFFFEFFE; + z = 64'h5560000800000FFE; + ans = 64'h5560000800000FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3044211\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3044825\n"); + end + x = 64'h801FE00000000FFF; + y = 64'hFF0003FDFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3045439\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hC3EFFFFFFFF0003E; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3046053\n"); + end + x = 64'h90B67083F2F3B2BE; + y = 64'h8021AA0E74B7BE9A; + z = 64'h344A4B5F400DAE2F; + ans = 64'h344A4B5F400DAE2F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3046667\n"); + end + x = 64'h434FFFFF8000003E; + y = 64'hBFD0000000000001; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'hC32FFFFF80000038; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3047281\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h38200000040FFFFF; + z = 64'h45BEFFFFEFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3047895\n"); + end + x = 64'hC3D000000001FFDE; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC80FFFFFFFFDF800; + ans = 64'hC80FFFFFFFFDF800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3048509\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h3801FFFFF7FFFFFF; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3049123\n"); + end + x = 64'hC0B000000000100E; + y = 64'h43FFFFFBFFFFEFFF; + z = 64'h40200000000FFEFF; + ans = 64'hC4BFFFFC0000101B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3049737\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBFE0000000000001; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3050351\n"); + end + x = 64'hC47F9B896EE345AF; + y = 64'hB7FE6C64EA47F3E0; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3050965\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h16FFFC03FFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3051579\n"); + end + x = 64'h41C0000082000000; + y = 64'h41E01FFFFFFBFFFF; + z = 64'hC05FFFFFFFF00001; + ans = 64'h43B0200082FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3052193\n"); + end + x = 64'h3FFFF800003FFFFE; + y = 64'hBFF0000000000000; + z = 64'h4000000000000000; + ans = 64'h3F5FFFFF00000800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3052807\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h381FFFF800FFFFFE; + z = 64'hBFE7942C107C146D; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3053421\n"); + end + x = 64'h0000EC4C3D4CE00C; + y = 64'hBFF0000000000001; + z = 64'hC7F0020000000003; + ans = 64'hC7F0020000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3054035\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hFFEFFFFFBFFFDFFF; + z = 64'hBCA0000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3054649\n"); + end + x = 64'hC0CDFFFFEFFFFFFE; + y = 64'h3EBFFFFFFE800000; + z = 64'h400000000BFFFFFF; + ans = 64'h3FFF880018459FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3055263\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hC000000000000000; + z = 64'h3FD0000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3055877\n"); + end + x = 64'hB7EFBFEFFFFFFFFF; + y = 64'hC01FFBFFFFF7FFFF; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3056491\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hC000000000000001; + z = 64'h3F3FFFFFFFFBFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3057105\n"); + end + x = 64'hBC1A7DA73DBA86FA; + y = 64'hBFB0000002FFFFFF; + z = 64'h384EFFFFFFFFFFFE; + ans = 64'h3BDA7DA742B21654; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3057719\n"); + end + x = 64'hC07D6677D809944E; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h409D6A77D809944C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3058333\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBFBFFFFFF8001FFF; + z = 64'h3B1FC0000000000F; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3058947\n"); + end + x = 64'h3FFFFFFFFFFFC00E; + y = 64'hC010000000000000; + z = 64'hC1C0000000403FFE; + ans = 64'hC1C0000004403FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3059561\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h4000000200001000; + z = 64'h8010000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3060175\n"); + end + x = 64'hD50000000000FFFF; + y = 64'h41D007FFFFBFFFFF; + z = 64'hFFF0000000800400; + ans = 64'hFFF8000000800400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3060789\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h3CA0000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3061403\n"); + end + x = 64'hC026021B608EA2C6; + y = 64'hBFE00000001FFFFD; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3062017\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hC340000000000000; + z = 64'h37EFFEFBFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3062631\n"); + end + x = 64'h4E82000000000010; + y = 64'hC1D2D177358C80A2; + z = 64'hC03FFFFFFFBFFC00; + ans = 64'hD0652BA61C3E10C9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3063245\n"); + end + x = 64'hC346D9C6FAF76368; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h46A6D9C6FAF76367; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3063859\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hC3CFFFFFF800000F; + z = 64'h7FFFFFEFFFFFFFBF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3064473\n"); + end + x = 64'hB54BFFE5FD756E11; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h674E709D89CD1045; + ans = 64'h674E709D89CD1045; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3065087\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hB7FFFFFFFBFFFFF7; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3065701\n"); + end + x = 64'h3FC00003FC000000; + y = 64'h41CFFFFFFF0007FE; + z = 64'h8010007FFFFBFFFF; + ans = 64'h41A00003FB8003DF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3066315\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3066929\n"); + end + x = 64'h28157F6040613C66; + y = 64'h705800FFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'h588020342B4AF055; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3067543\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h41C01FFFFBFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3068157\n"); + end + x = 64'hBFFFFFFFFE000FFE; + y = 64'h41E1327FFABA4463; + z = 64'hB7FFFFFFFFC00000; + ans = 64'hC1F1327FF9A724FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3068771\n"); + end + x = 64'hC05FFFFF80000000; + y = 64'hFFF0000000000001; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3069385\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h3FC4E9D3D378B53D; + z = 64'h3FA000200000000F; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3069999\n"); + end + x = 64'hC06FFFF7FFFFFFFB; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hC030001FFFFFFFFD; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3070613\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h403F5FC3BCD9FA44; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3071227\n"); + end + x = 64'hC02E18F44A3E03BD; + y = 64'h3FA00000FFFFFFF8; + z = 64'hFFF00000000FFFFF; + ans = 64'hFFF80000000FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3071841\n"); + end + x = 64'h8000000000000000; + y = 64'h0000000000000001; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h000FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3072455\n"); + end + x = 64'hBFEA884E50247B88; + y = 64'hC39A5B2CF6AC3C47; + z = 64'hC010000000000000; + ans = 64'h4395DA5887C3E2F7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3073069\n"); + end + x = 64'h8000000000000000; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h43D02FFFFFFFFFFF; + ans = 64'h43D02FFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3073683\n"); + end + x = 64'hC1F3FBFFFFFFFFFF; + y = 64'h3CA00000000017FF; + z = 64'hDE3BFDFFFFFFFFFF; + ans = 64'hDE3BFDFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3074297\n"); + end + x = 64'h3FCFFFFFEFFFFFBF; + y = 64'h0010000000000000; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3074911\n"); + end + x = 64'h8000000000000000; + y = 64'hC1F457645C6077D2; + z = 64'h41CE000007FFFFFF; + ans = 64'h41CE000007FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3075525\n"); + end + x = 64'hED901FFFFFFFFFF7; + y = 64'h0010000000000001; + z = 64'h43C0003FFFFFF7FF; + ans = 64'h43C0003FFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3076139\n"); + end + x = 64'h8000000000000000; + y = 64'hC030000040400000; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3076753\n"); + end + x = 64'h3FC021FFFFFFFFFE; + y = 64'hBCAF7FFFEFFFFFFE; + z = 64'hC341F7FFFFFFFFFE; + ans = 64'hC341F7FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3077367\n"); + end + x = 64'h8000000000000000; + y = 64'h3CA0000000000000; + z = 64'h0000000000000000; + ans = 64'h0000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3077981\n"); + end + x = 64'h47EFFFFFFF804000; + y = 64'h802FFFFFFC100000; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3078595\n"); + end + x = 64'h8000000000000000; + y = 64'h3CA0000000000001; + z = 64'hC032000000000FFF; + ans = 64'hC032000000000FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3079209\n"); + end + x = 64'hFFF0100000007FFF; + y = 64'hBE50007F80000000; + z = 64'hC3450907904A895D; + ans = 64'hFFF8100000007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3079823\n"); + end + x = 64'h7FEFC3FFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h3CA0000000000001; + ans = 64'h7CAFC3FFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3080437\n"); + end + x = 64'h8000000000000000; + y = 64'hC3FBC0311875347E; + z = 64'h404740F81BE91948; + ans = 64'h404740F81BE91948; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3081051\n"); + end + x = 64'h40F0003FC0000000; + y = 64'h3FD0000000000000; + z = 64'h41E9224C4FC48A71; + ans = 64'h41E922544FE46A71; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3081665\n"); + end + x = 64'h8000000000000000; + y = 64'h7FF001FFFFFF7FFF; + z = 64'h7FE0000000000001; + ans = 64'h7FF801FFFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3082279\n"); + end + x = 64'h3FC0020007FFFFFE; + y = 64'h3FFD07336C3C07A2; + z = 64'hAE1A599530074107; + ans = 64'h3FCD0AD4612D28D5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3082893\n"); + end + x = 64'h8000000000000000; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3083507\n"); + end + x = 64'h001BB71BCC644518; + y = 64'h3CCA1657CF69F990; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3084121\n"); + end + x = 64'h8000000000000000; + y = 64'h3FE0000000000000; + z = 64'hFFFB22B4429E5973; + ans = 64'hFFFB22B4429E5973; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3084735\n"); + end + x = 64'hC6503FFFFFFFFFEF; + y = 64'hC80FFFFF803FFFFE; + z = 64'h4800100002000000; + ans = 64'h4E703FFFBF207FEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3085349\n"); + end + x = 64'h404FFFFFFF802000; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h404FFFFFFF801FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3085963\n"); + end + x = 64'h8000000000000000; + y = 64'h43DFFE0000000002; + z = 64'h3FCFFFC00001FFFF; + ans = 64'h3FCFFFC00001FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3086577\n"); + end + x = 64'h37EFF003FFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h455000003FFFEFFF; + ans = 64'h455000003FFFEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3087191\n"); + end + x = 64'h8000000000000000; + y = 64'hC1D4D2909DF566D4; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3087805\n"); + end + x = 64'hCC70E9EB1B349793; + y = 64'h405FC00000000020; + z = 64'hC26100003FFFFFFE; + ans = 64'hCCE0C81744FE2E75; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3088419\n"); + end + x = 64'h8000000000000000; + y = 64'h3FF0000000000001; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3089033\n"); + end + x = 64'hECD000FDFFFFFFFF; + y = 64'h40800000000003DE; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hED6000FE000003DD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3089647\n"); + end + x = 64'h8000000000000000; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h22DFFFFFFEFFF7FF; + ans = 64'h22DFFFFFFEFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3090261\n"); + end + x = 64'hC000010003FFFFFF; + y = 64'h43D0080000000800; + z = 64'h5B3C1ACD83585189; + ans = 64'h5B3C1ACD83585189; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3090875\n"); + end + x = 64'hC7EFFBFFFFFFFEFF; + y = 64'h4000000000000001; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'hC7FFFBFFFFFFFF01; rn = 1; rz = 0; rm = 0; @@ -72185,9 +236685,9 @@ initial $fwrite(fp,"3091489\n"); end x = 64'h8000000000000000; - y = 64'h401FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + y = 64'h3F2888DBBA853F4F; + z = 64'h43BFFFFFFFC00008; + ans = 64'h43BFFFFFFFC00008; rn = 1; rz = 0; rm = 0; @@ -72229,12 +236729,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3093503\n"); + $fwrite(fp,"3092103\n"); end - x = 64'h381FFFFFFFBFFFFD; - y = 64'h434FFFFFFFFFFFFF; - z = 64'h3FC13FC964804937; - ans = 64'h3FC13FC964804937; + x = 64'h3FC000001FFBFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h3808347E56DF1CFB; + ans = 64'h3FE000001FFBFFFE; rn = 1; rz = 0; rm = 0; @@ -72276,59 +236776,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3095517\n"); - end - x = 64'hBAE49B6CCC5D9A1D; - y = 64'hC00FFFFFFFFFFF40; - z = 64'h000FFFFFFFFFFFED; - ans = 64'h3B049B6CCC5D99A1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3097531\n"); + $fwrite(fp,"3092717\n"); end x = 64'h8000000000000000; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFF77FF; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFF77FF; rn = 1; rz = 0; rm = 0; @@ -72370,12 +236823,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3099545\n"); + $fwrite(fp,"3093331\n"); end - x = 64'hFFE0044000000000; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'h7FD0000020000000; - ans = 64'h7FFFFFFFFFFFFFFF; + x = 64'hB19FFFFFFFFFFBFE; + y = 64'hC01FFFFDFFFDFFFF; + z = 64'h24DFE0000000003F; + ans = 64'h31CFFFFDFFFDFBFD; rn = 1; rz = 0; rm = 0; @@ -72417,59 +236870,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3101559\n"); - end - x = 64'hE31FFFF7FFFC0000; - y = 64'hBFE0003FFFFFFFFF; - z = 64'h41C000000000001F; - ans = 64'h6310003BFFEDFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3103573\n"); + $fwrite(fp,"3093945\n"); end x = 64'h8000000000000000; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; + y = 64'h4010000000000000; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -72511,12 +236917,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3105587\n"); + $fwrite(fp,"3094559\n"); end - x = 64'h4BF0082000000000; - y = 64'h8010000000000001; - z = 64'h405E040000000000; - ans = 64'h405E040000000000; + x = 64'hBFC08000007FFFFF; + y = 64'hC01FFF7FFFFEFFFF; + z = 64'hBFE0000000000000; + ans = 64'h3FE0FF7C00FEF3FD; rn = 1; rz = 0; rm = 0; @@ -72558,57 +236964,339 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3107601\n"); - end - x = 64'hD1FFFFFFFF9FFFFF; - y = 64'hFFF0040000010000; - z = 64'h3DBFFFFFFF7FFF7F; - ans = 64'hFFF8040000010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3109615\n"); + $fwrite(fp,"3095173\n"); end x = 64'h8000000000000000; - y = 64'hBCAFFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h41FFFFFFFFFFF7EF; + ans = 64'h41FFFFFFFFFFF7EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3095787\n"); + end + x = 64'h403DB03B87843F76; + y = 64'hBF800000000FF7FF; + z = 64'hC1EFFFFFFFFFFFFF; + ans = 64'hC1F000000003B607; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3096401\n"); + end + x = 64'h43F0007F7FFFFFFE; + y = 64'h4340000000000000; + z = 64'h0000000000000000; + ans = 64'h4740007F7FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3097015\n"); + end + x = 64'h8000000000000000; + y = 64'h45500000BFFFFFFE; + z = 64'h4017E8D64105A119; + ans = 64'h4017E8D64105A119; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3097629\n"); + end + x = 64'h401FFFFFFDFFFFFF; + y = 64'h4340000000000001; + z = 64'hBFC01EFFFFFFFFFE; + ans = 64'h436FFFFFFE000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3098243\n"); + end + x = 64'h8000000000000000; + y = 64'h3FDFFC0001FFFFFF; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3098857\n"); + end + x = 64'hC1CFF7FFFFEFFFFF; + y = 64'hBDE0005FFFFFFFFF; + z = 64'hC7F0000000803FFF; + ans = 64'hC7F0000000803FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3099471\n"); + end + x = 64'h8000000000000000; + y = 64'h434FFFFFFFFFFFFE; z = 64'hC340000000000000; ans = 64'hC340000000000000; rn = 1; @@ -72652,12 +237340,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3111629\n"); + $fwrite(fp,"3100085\n"); end - x = 64'h406FFE0000FFFFFE; - y = 64'hBFD0000000000001; - z = 64'h400F499C83E9329A; - ans = 64'hC04E096638C16CD6; + x = 64'hC030A7CF373B62D5; + y = 64'hBF4D228689037BA6; + z = 64'hBFD0000000000001; + ans = 64'hBFCE1ABE7C78711C; rn = 1; rz = 0; rm = 0; @@ -72699,59 +237387,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3113643\n"); - end - x = 64'hBF4000401FFFFFFF; - y = 64'h37043FFFFFFFFFFF; - z = 64'h43E22053F97A12DC; - ans = 64'h43E22053F97A12DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3115657\n"); + $fwrite(fp,"3100699\n"); end x = 64'h8000000000000000; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'hCC7001FDFFFFFFFF; + ans = 64'hCC7001FDFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -72793,12 +237434,1657 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3117671\n"); + $fwrite(fp,"3101313\n"); end - x = 64'hC05FFFFFFFDEFFFF; + x = 64'hC1C0FFFFFF7FFFFF; + y = 64'h40070F82E6044AF0; + z = 64'h3E5FFC000000001F; + ans = 64'hC1D8807B13AC1386; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3101927\n"); + end + x = 64'h3FBFFFDFF7FFFFFF; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3102541\n"); + end + x = 64'h8000000000000000; + y = 64'hC03000003FFE0000; + z = 64'h3FF00000000007FF; + ans = 64'h3FF00000000007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3103155\n"); + end + x = 64'hC80FFFFFFFDFFFF6; + y = 64'h7FF0000000000000; + z = 64'h802ACE332F4C4763; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3103769\n"); + end + x = 64'h8000000000000000; + y = 64'hB7E0000000007FFB; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3104383\n"); + end + x = 64'hC80DB237A7B2ECFA; + y = 64'h43CF7FFF00000000; + z = 64'hC0942C91CBC6742F; + ans = 64'hCBED3B6DDB826409; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3104997\n"); + end + x = 64'h8000000000000000; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hC010000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3105611\n"); + end + x = 64'hBD800000FFEFFFFF; + y = 64'hBCA000000000047F; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3106225\n"); + end + x = 64'h8000000000000000; + y = 64'h8000000000000000; + z = 64'h3FF00000007FF000; + ans = 64'h3FF00000007FF000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3106839\n"); + end + x = 64'hC03D0F79F2E2110C; + y = 64'hC03000FFFFFFFFEF; + z = 64'h001E8FC2A817327E; + ans = 64'h407D114AEA813F0E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3107453\n"); + end + x = 64'h4010000003FFC000; + y = 64'h8000000000000001; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3108067\n"); + end + x = 64'h8000000000000000; + y = 64'hBFAC4EA8DFBA2E0F; + z = 64'h2EAFFBE000000000; + ans = 64'h2EAFFBE000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3108681\n"); + end + x = 64'hC1CFFDFFFC000000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h3FBFFFFFFFDFFFBF; + ans = 64'h3FBFFFFFFFDFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3109295\n"); + end + x = 64'h8000000000000000; + y = 64'hEF50DFFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3109909\n"); + end + x = 64'hBFEFFF7FFC000000; + y = 64'h802C0000000007FF; + z = 64'hC34020C551346F33; + ans = 64'hC34020C551346F33; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3110523\n"); + end + x = 64'h8000000000000000; + y = 64'h8010000000000001; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3111137\n"); + end + x = 64'h4016D2AF65546489; + y = 64'h802FFFF00003FFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h8058D2A3FBFF8C33; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3111751\n"); + end + x = 64'h8000000000000000; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBF5000001FFFFF7F; + ans = 64'hBF5000001FFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3112365\n"); + end + x = 64'hBC494CF44BE411E4; + y = 64'h40D0800FFFFFFFFF; + z = 64'h3F2FF0000003FFFE; + ans = 64'h3F2FEFFFFFE9E889; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3112979\n"); + end + x = 64'hC0B0400000010000; + y = 64'hBCA0000000000000; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3113593\n"); + end + x = 64'h8000000000000000; + y = 64'h43CFFFFFF803FFFF; + z = 64'hFFFFDFFDFFFFFFFE; + ans = 64'hFFFFDFFDFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3114207\n"); + end + x = 64'h43400047FFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hBFD75FA2A3A89086; + ans = 64'hC002EC3C5475120F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3114821\n"); + end + x = 64'h8000000000000000; + y = 64'hB4CFFFFFFFFBFF00; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3115435\n"); + end + x = 64'hD64FFFFFF0080000; + y = 64'hD1DDB24D08FC815F; + z = 64'hC660000001000000; + ans = 64'h683DB24CFA2AC76E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3116049\n"); + end + x = 64'h8000000000000000; + y = 64'hBFD0000000000000; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3116663\n"); + end + x = 64'h000FFF000000000F; + y = 64'h3FF00800001FFFFF; + z = 64'h8010000000000000; + ans = 64'h000006FF801FFE0E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3117277\n"); + end + x = 64'h8000000000000000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h2BAFFFFE00000400; + ans = 64'h2BAFFFFE00000400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3117891\n"); + end + x = 64'h9A73CCE1CA1D11E1; + y = 64'h47EFFFFF07FFFFFF; + z = 64'h380E615AE8E06D92; + ans = 64'h380E615AE8E06D92; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3118505\n"); + end + x = 64'h43E000FFFFFFDFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC3D008FFFFFFDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3119119\n"); + end + x = 64'h8000000000000000; + y = 64'hB7E4D7D8D41529FE; + z = 64'hC7F10000001FFFFF; + ans = 64'hC7F10000001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3119733\n"); + end + x = 64'h480FFFC000000004; + y = 64'hBFE0000000000001; + z = 64'hFFDFE0000003FFFF; + ans = 64'hFFDFE0000003FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3120347\n"); + end + x = 64'h8000000000000000; + y = 64'h593FF0000FFFFFFF; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3120961\n"); + end + x = 64'hC06B9417C0033A6E; + y = 64'h7FD0200000002000; + z = 64'hC1C00000004001FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3121575\n"); + end + x = 64'h8000000000000000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBFF0000000000000; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3122189\n"); + end + x = 64'h4760000FF7FFFFFF; + y = 64'hC020001000001FFF; + z = 64'h8000000000000001; + ans = 64'hC790001FF81017FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3122803\n"); + end + x = 64'h8000000000000000; y = 64'hBFF0000000000001; - z = 64'hC01000000007DFFF; - ans = 64'h405EFFFFFFDE8201; + z = 64'h41EE7FFFFFFFFFFF; + ans = 64'h41EE7FFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -72840,12 +239126,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3119685\n"); + $fwrite(fp,"3123417\n"); end - x = 64'h400040000007FFFF; - y = 64'hBFA738FE57513611; - z = 64'hC0200000000081FF; - ans = 64'hC0202F2BC4A1F62E; + x = 64'hB7F000000003FFFC; + y = 64'hC3EBFFFFC0000000; + z = 64'h4340020000007FFF; + ans = 64'h4340020000007FFF; rn = 1; rz = 0; rm = 0; @@ -72887,10 +239173,574 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3121699\n"); + $fwrite(fp,"3124031\n"); + end + x = 64'h00156990261BEC37; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3124645\n"); + end + x = 64'h8000000000000000; + y = 64'hB7FFFFFFFFFF03FF; + z = 64'hEEDF000000000200; + ans = 64'hEEDF000000000200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3125259\n"); + end + x = 64'h8021FFFFFFFF7FFF; + y = 64'hC000000000000000; + z = 64'h41DF7FFFFFDFFFFF; + ans = 64'h41DF7FFFFFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3125873\n"); + end + x = 64'h8000000000000000; + y = 64'h4013FFFFFFFFFFDF; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3126487\n"); + end + x = 64'hC02FFFFFBFFFFEFF; + y = 64'h3C0EBC9683E33424; + z = 64'h2BCFFFFFF0000000; + ans = 64'hBC4EBC96466A0625; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3127101\n"); end x = 64'h8000000000000000; y = 64'hC00FFFFFFFFFFFFF; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3127715\n"); + end + x = 64'hC0200800000003FF; + y = 64'hC05BFA48DAC0DE8C; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3128329\n"); + end + x = 64'h8000000000000000; + y = 64'hC010000000000000; + z = 64'hBFCFE49E2BE245B9; + ans = 64'hBFCFE49E2BE245B9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3128943\n"); + end + x = 64'h41C000FFFFFFFEFF; + y = 64'h3FBCFA3A6B7AD55E; + z = 64'h3FDFFFFFFFFFE020; + ans = 64'h418CFC0A13218B3A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3129557\n"); + end + x = 64'h42B0000000800002; + y = 64'hC010000000000001; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC2D0000000800103; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3130171\n"); + end + x = 64'h8000000000000000; + y = 64'h2CFFFBFFFFFFFFF6; + z = 64'h3FE07FFFFFFBFFFE; + ans = 64'h3FE07FFFFFFBFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3130785\n"); + end + x = 64'h802000000001F7FE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h40307FFFFFFFFFFD; + ans = 64'h40307FFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3131399\n"); + end + x = 64'h8000000000000000; + y = 64'h47AF7DFFFFFFFFFF; z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; @@ -72934,12 +239784,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3123713\n"); + $fwrite(fp,"3132013\n"); end - x = 64'hBF2000FEFFFFFFFE; - y = 64'hC010000000000000; - z = 64'hC7F5A230266AE7A3; - ans = 64'hC7F5A230266AE7A3; + x = 64'hBFB00000002FFFFE; + y = 64'h449FFFFFFFFEF7FE; + z = 64'hC07000000FF7FFFE; + ans = 64'hC4600000002F7BFD; rn = 1; rz = 0; rm = 0; @@ -72981,59 +239831,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3125727\n"); - end - x = 64'h43DFFFFFFFFFFFF4; - y = 64'h3FCFEFE000000000; - z = 64'h306FFFFFFFFE4000; - ans = 64'h43BFEFDFFFFFFFF4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3127741\n"); + $fwrite(fp,"3132627\n"); end x = 64'h8000000000000000; y = 64'hC340000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -73075,12 +239878,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3129755\n"); + $fwrite(fp,"3133241\n"); end - x = 64'h3FFFF7FFFFDFFFFF; - y = 64'hFFE0000000000000; - z = 64'hBFB97642758A8451; - ans = 64'hFFEFF7FFFFDFFFFF; + x = 64'hC3CFFFFFFE00000F; + y = 64'h401FA0393503D82D; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -73122,59 +239925,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3131769\n"); - end - x = 64'h900FFFFFE000FFFE; - y = 64'h381300275946B79C; - z = 64'hC340000120000000; - ans = 64'hC340000120000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3133783\n"); + $fwrite(fp,"3133855\n"); end x = 64'h8000000000000000; - y = 64'hFFF0000000000001; - z = 64'h4340000000000000; - ans = 64'hFFF8000000000001; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3E9FFC0000000400; + ans = 64'h3E9FFC0000000400; rn = 1; rz = 0; rm = 0; @@ -73216,11 +239972,481 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3135797\n"); + $fwrite(fp,"3134469\n"); end - x = 64'hB46FF00000003FFF; + x = 64'h41CFFFF3FFFFFFFE; + y = 64'h37F19D07D7E0590A; + z = 64'hBCAFFFFFFC00FFFF; + ans = 64'hBCAFFFFFFC00FF72; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3135083\n"); + end + x = 64'h3F6FFFFFFF003FFE; + y = 64'hFFE0000000000000; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hFF5FFFFFFF003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3135697\n"); + end + x = 64'h8000000000000000; + y = 64'h43400001FFFFF7FE; + z = 64'h43E002FFFFFFFFFF; + ans = 64'h43E002FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3136311\n"); + end + x = 64'hC1F6144314164BCD; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h40F003FFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3136925\n"); + end + x = 64'h8000000000000000; + y = 64'hC019164BC4066991; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h001FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3137539\n"); + end + x = 64'hB8000000010003FF; + y = 64'hC0F46B4BFE151F0B; + z = 64'h38000000001BFFFF; + ans = 64'h39046B5BFF5BD900; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3138153\n"); + end + x = 64'h8000000000000000; + y = 64'hFFF0000000000000; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hFFF8000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3138767\n"); + end + x = 64'hC2900000001FFEFE; + y = 64'hC065A4DA1815F209; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3139381\n"); + end + x = 64'h8000000000000000; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hA90FFFF000000080; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3139995\n"); + end + x = 64'h434FFFFFFDFFFFF7; + y = 64'h43DFFFFC00001FFF; + z = 64'hBAB00003FFDFFFFF; + ans = 64'h473FFFFBFE002036; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3140609\n"); + end + x = 64'hCFFFFFFFFFFFFFFF; y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h406FFFFFFF7FFFF8; + z = 64'hBFF0000000000000; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -73263,59 +240489,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3137811\n"); - end - x = 64'h47E00010007FFFFF; - y = 64'h40266EBEA38FE729; - z = 64'hC1F0001001FFFFFE; - ans = 64'h48166ED5130200AD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3139825\n"); + $fwrite(fp,"3141223\n"); end x = 64'h8000000000000001; - y = 64'h0010000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + y = 64'h3F90080000000000; + z = 64'hC1F000001FFFFFE0; + ans = 64'hC1F000001FFFFFE0; rn = 1; rz = 0; rm = 0; @@ -73357,12 +240536,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3141839\n"); + $fwrite(fp,"3141837\n"); end - x = 64'hC010008000000002; - y = 64'h001FFFFFFFFFFFFE; - z = 64'hC34D53BC32062817; - ans = 64'hC34D53BC32062817; + x = 64'hC7E0000040000FFE; + y = 64'h0000000000000001; + z = 64'h37E0000000000011; + ans = 64'h37E0000000000011; rn = 1; rz = 0; rm = 0; @@ -73404,12 +240583,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3143853\n"); + $fwrite(fp,"3142451\n"); end - x = 64'h3C20001FFEFFFFFF; - y = 64'h1DA4B9C4C2406E55; - z = 64'hB800000DFFFFFFFF; - ans = 64'hB800000DFFFFFFFF; + x = 64'h8000000000000001; + y = 64'h400EFFFFFF000000; + z = 64'h0010000000000000; + ans = 64'h000FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -73451,12 +240630,576 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3145867\n"); + $fwrite(fp,"3143065\n"); + end + x = 64'h43EDDFB09753FFA6; + y = 64'h37AFFFF003FFFFFF; + z = 64'h3FF1C45D282E7E53; + ans = 64'h3FF1C45D282E7E53; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3143679\n"); + end + x = 64'h8000000000000001; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hBCA0000000000000; + ans = 64'hBCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3144293\n"); + end + x = 64'hBFD00003FFFFFFEF; + y = 64'hBFDACEDC26695437; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3144907\n"); + end + x = 64'h8000000000000001; + y = 64'h0010000000000001; + z = 64'hC1C1DFFFFFFFFFFF; + ans = 64'hC1C1DFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3145521\n"); + end + x = 64'h4040000000000801; + y = 64'hC7800007FFFFFFEF; + z = 64'hC04FFFFFFFFBFFEF; + ans = 64'hC7D00008000007F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3146135\n"); + end + x = 64'hC35FFFFD7FFFFFFE; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3146749\n"); + end + x = 64'h8000000000000001; + y = 64'h3FDFFFFE007FFFFF; + z = 64'h3940C6BA3B0B3184; + ans = 64'h3940C6BA3B0B3184; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3147363\n"); + end + x = 64'h7FFFF00000000000; + y = 64'h3CA0000000000000; + z = 64'hBBA00000000EFFFF; + ans = 64'h7FFFF00000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3147977\n"); + end + x = 64'h8000000000000001; + y = 64'h40211275FFE5EE3C; + z = 64'h0000000000000001; + ans = 64'h8000000000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3148591\n"); + end + x = 64'hC0C00000013FFFFE; + y = 64'h4067902331AAF6C5; + z = 64'h380FFFFFFFE00000; + ans = 64'hC137902333823982; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3149205\n"); + end + x = 64'h8000000000000001; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h8010000000000001; + ans = 64'h8010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3149819\n"); + end + x = 64'hC050000000010000; + y = 64'hBF1003FFFFF7FFFE; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h402002007FFFFF20; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3150433\n"); end x = 64'h8000000000000001; y = 64'h3FD0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3FDFFFFFFBF80000; + ans = 64'h3FDFFFFFFBF80000; rn = 1; rz = 0; rm = 0; @@ -73498,12 +241241,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3147881\n"); + $fwrite(fp,"3151047\n"); end - x = 64'hC3FFFFFFFFEFFEFF; + x = 64'h41A2FFFFFFFFFFFF; + y = 64'hC01F4C181CF9031A; + z = 64'h59EAEF43B21B025D; + ans = 64'h59EAEF43B21B025D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3151661\n"); + end + x = 64'h2F4FFFFFFFBFFF7F; + y = 64'h3FD0000000000001; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3152275\n"); + end + x = 64'h8000000000000001; + y = 64'hC1C01FFFFFFFFEFE; + z = 64'h03100007FE000000; + ans = 64'h03100007FE000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3152889\n"); + end + x = 64'h41D0000100000800; y = 64'h3FDFFFFFFFFFFFFE; - z = 64'hC01FFFFC07FFFFFF; - ans = 64'hC3EFFFFFFFEFFEFD; + z = 64'h37000000000FFEFF; + ans = 64'h41C00001000007FF; rn = 1; rz = 0; rm = 0; @@ -73545,59 +241429,294 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3149895\n"); - end - x = 64'hBEF0000000003FFB; - y = 64'h7FFFFFFFFFFFA000; - z = 64'h3DC8000000040000; - ans = 64'h7FFFFFFFFFFFA000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3151909\n"); + $fwrite(fp,"3153503\n"); end x = 64'h8000000000000001; + y = 64'hBFD00000003FFFFF; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3154117\n"); + end + x = 64'h3FCFFFFDFFFFFFFE; + y = 64'hB5A72C97AC0E810C; + z = 64'hC3D000000040001F; + ans = 64'hC3D000000040001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3154731\n"); + end + x = 64'h8000000000000001; + y = 64'h3FE0000000000001; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h8010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3155345\n"); + end + x = 64'h3E1E236829225737; + y = 64'hB7E405088A99DC41; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3155959\n"); + end + x = 64'h8000000000000001; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h3CAFFFFC003FFFFF; + ans = 64'h3CAFFFFC003FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3156573\n"); + end + x = 64'h9EAF803FFFFFFFFF; + y = 64'h985FFFFC000007FF; + z = 64'hBFBFFE007FFFFFFE; + ans = 64'hBFBFFE007FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3157187\n"); + end + x = 64'h3FDFFFFFE03FFFFF; y = 64'h3FF0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFE03FFFFB; rn = 1; rz = 0; rm = 0; @@ -73639,12 +241758,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3153923\n"); + $fwrite(fp,"3157801\n"); end - x = 64'h480473FEE0C956B1; + x = 64'h8000000000000001; + y = 64'h3817CB84DBC4B68E; + z = 64'hC03F153C7B568390; + ans = 64'hC03F153C7B568390; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3158415\n"); + end + x = 64'h41CFFFFFFFFFDFDE; y = 64'h3FFFFFFFFFFFFFFF; - z = 64'hBD7BBDB3AEF5F51A; - ans = 64'h481473FEE0C956B0; + z = 64'h3FBFFDFFFF000000; + ans = 64'h41E000000003EFAE; rn = 1; rz = 0; rm = 0; @@ -73686,59 +241852,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3155937\n"); - end - x = 64'hBF1FFFFFFFFFEFBE; - y = 64'h4060001FFF7FFFFE; - z = 64'hBFB9717E7198CA76; - ans = 64'hBFBD71867178C86D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3157951\n"); + $fwrite(fp,"3159029\n"); end x = 64'h8000000000000001; - y = 64'h400FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + y = 64'hC03FFFFFFFFFFFFF; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -73780,12 +241899,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3159965\n"); + $fwrite(fp,"3159643\n"); end - x = 64'hC1DFFFFFC0000FFE; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h8013FBFFFFFFFFFF; - ans = 64'hC20FFFFFC0000FFD; + x = 64'h41CA0E88599F6184; + y = 64'hC34FFFFF801FFFFE; + z = 64'h43D000400FFFFFFF; + ans = 64'hC52A0E87717D4E24; rn = 1; rz = 0; rm = 0; @@ -73827,57 +241946,10 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3161979\n"); - end - x = 64'h43100200003FFFFF; - y = 64'hB7E000000DFFFFFE; - z = 64'h47EF5361DE548D5B; - ans = 64'h47EF5361DE548D5B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3163993\n"); + $fwrite(fp,"3160257\n"); end x = 64'h8000000000000001; - y = 64'h434FFFFFFFFFFFFE; + y = 64'h4000000000000000; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -73921,12 +241993,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3166007\n"); + $fwrite(fp,"3160871\n"); end - x = 64'hB7EFFFFFFF800000; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'hBF224D4C54ADBF54; - ans = 64'hF7EFFFFFFF7FFFFF; + x = 64'h41CFFFFFFFFFEFF0; + y = 64'hC02FFBFFFFFFF7FF; + z = 64'h4000000000000000; + ans = 64'hC20FFBFFFFEFE7F1; rn = 1; rz = 0; rm = 0; @@ -73968,58 +242040,1045 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3168021\n"); - end - x = 64'hC00001FFFFFFFDFE; - y = 64'h47FFFFFFFFF3FFFF; - z = 64'hCD8000001F7FFFFE; - ans = 64'hCD8000001F7FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3170035\n"); + $fwrite(fp,"3161485\n"); end x = 64'h8000000000000001; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h3FD0800002000000; + ans = 64'h3FD0800002000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3162099\n"); + end + x = 64'hC07000000000005E; + y = 64'h3F20000000103FFF; + z = 64'hC1D07FFF7FFFFFFF; + ans = 64'hC1D07FFF8001FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3162713\n"); + end + x = 64'hBFC01FFFFFFFFE00; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hBCA0000000000000; + ans = 64'hBFE01FFFFFFFFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3163327\n"); + end + x = 64'h8000000000000001; + y = 64'hBEE0000807FFFFFE; + z = 64'hD47000001E000000; + ans = 64'hD47000001E000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3163941\n"); + end + x = 64'hB81DAD3FB1C8BFCB; + y = 64'h4010000000000001; + z = 64'hC03FFE0FFFFFFFFE; + ans = 64'hC03FFE0FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3164555\n"); + end + x = 64'h8000000000000001; + y = 64'hC15FFBFFFFFFFBFF; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3165169\n"); + end + x = 64'h400C05A976082539; + y = 64'h3B20008007FFFFFF; + z = 64'h4000200000200000; + ans = 64'h4000200000200000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3165783\n"); + end + x = 64'h8000000000000001; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3166397\n"); + end + x = 64'h43EF3C4FB6317308; + y = 64'h401FA877217B4DCA; + z = 64'h3FF0000000000001; + ans = 64'h441EE6DE23F36688; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3167011\n"); + end + x = 64'h8000000000000001; + y = 64'h4340000000000001; + z = 64'h43FFFFFFFFFFFDF7; + ans = 64'h43FFFFFFFFFFFDF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3167625\n"); + end + x = 64'h381B8A7CEA43CD38; + y = 64'hBCA00000000000FE; + z = 64'hBFCFF7FFFFFFFBFF; + ans = 64'hBFCFF7FFFFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3168239\n"); + end + x = 64'h3FC0003000000000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h8010000000000001; + ans = 64'h4320002FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3168853\n"); + end + x = 64'h8000000000000001; + y = 64'hC1C8000007FFFFFE; + z = 64'hC3CC26562E83F4EA; + ans = 64'hC3CC26562E83F4EA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3169467\n"); + end + x = 64'hC0039AA7F4BDCC1A; + y = 64'h7FE0000000000000; + z = 64'h2EFFFFFFFF0003FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3170081\n"); + end + x = 64'h8000000000000001; + y = 64'h7FEF848CC01517B4; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3170695\n"); + end + x = 64'h43CFFC0000000020; + y = 64'h4EF11317FB120971; + z = 64'h32A0000003BFFFFF; + ans = 64'h52D110F59812A741; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3171309\n"); + end + x = 64'h8000000000000001; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3171923\n"); + end + x = 64'hBE3FFFC1FFFFFFFE; + y = 64'h1500000000080008; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3172537\n"); + end + x = 64'h8000000000000001; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h410FFFFFFC007FFE; + ans = 64'h410FFFFFFC007FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3173151\n"); + end + x = 64'h7FFE07FFFFFFFFFF; + y = 64'h40FFFF3FFFFFFFFE; + z = 64'h47700F8000000000; + ans = 64'h7FFE07FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3173765\n"); + end + x = 64'hBFDFFFFFBFFFF7FF; + y = 64'h7FF0000000000001; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3174379\n"); + end + x = 64'h8000000000000001; + y = 64'hA2600000080000FF; + z = 64'hBCEB98ACD7FD8CA0; + ans = 64'hBCEB98ACD7FD8CA0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3174993\n"); + end + x = 64'hFFD0000000380000; y = 64'h7FFFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3F61000000100000; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -74062,12 +243121,106 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3172049\n"); + $fwrite(fp,"3175607\n"); end - x = 64'hBFBF0000000000FE; + x = 64'h8000000000000001; + y = 64'hBFE00007FFFEFFFF; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3176221\n"); + end + x = 64'h801FFFF000002000; + y = 64'h3E4000007FBFFFFF; + z = 64'hFFEFFFBFBFFFFFFE; + ans = 64'hFFEFFFBFBFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3176835\n"); + end + x = 64'h8000000000000001; y = 64'h8000000000000001; - z = 64'hE17FFFFFFFFF8007; - ans = 64'hE17FFFFFFFFF8007; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -74109,12 +243262,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3174063\n"); + $fwrite(fp,"3177449\n"); end - x = 64'h7A2E9622E5CA04A5; - y = 64'h21F6A376ABEF6748; - z = 64'hBFEFFF80000007FF; - ans = 64'h5C35A3762DB52E1B; + x = 64'hCA1FFFFFBFEFFFFF; + y = 64'h40104000000000FE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'hCA403FFFDF77E0FD; rn = 1; rz = 0; rm = 0; @@ -74156,12 +243309,200 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3176077\n"); + $fwrite(fp,"3178063\n"); end x = 64'h8000000000000001; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h50BFFFFF80000007; + ans = 64'h50BFFFFF80000007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3178677\n"); + end + x = 64'hC1F0010000001FFF; + y = 64'h4682F7C4BE71CF6A; + z = 64'h801FBC2C44B340E6; + ans = 64'hC882F8F43ABDDC75; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3179291\n"); + end + x = 64'h3FF000000080007F; + y = 64'h8010000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3179905\n"); + end + x = 64'h8000000000000001; + y = 64'h3F810000003FFFFE; + z = 64'h3FF7FFFFFFFFFFEF; + ans = 64'h3FF7FFFFFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3180519\n"); + end + x = 64'hBFB0009FFFFFFFFF; y = 64'h801FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; + z = 64'h47E14C1A2DD3B4B1; + ans = 64'h47E14C1A2DD3B4B1; rn = 1; rz = 0; rm = 0; @@ -74203,12 +243544,200 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3178091\n"); + $fwrite(fp,"3181133\n"); end - x = 64'hC080004000000100; + x = 64'h8000000000000001; + y = 64'hB7F000000000003E; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3181747\n"); + end + x = 64'hC9AFFFFFFEEFFFFF; + y = 64'hC030000001FFFFF6; + z = 64'h400000400000007F; + ans = 64'h49F000000177FFF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3182361\n"); + end + x = 64'h8000000000000001; + y = 64'hBCA0000000000000; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3182975\n"); + end + x = 64'h37E0010400000000; + y = 64'hB60E000040000000; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3183589\n"); + end + x = 64'h8000000000000001; y = 64'hBCA0000000000001; - z = 64'h36A000000000001B; - ans = 64'h3D30004000000101; + z = 64'h3FFEFFFFFFFFFFFD; + ans = 64'h3FFEFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -74250,12 +243779,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3180105\n"); + $fwrite(fp,"3184203\n"); end - x = 64'h3F4FFFFFFFFFFE06; - y = 64'h3FE121D0404AF4CC; - z = 64'h403EF7A477CB376D; - ans = 64'h403EF7C6BB6BB803; + x = 64'hC051984EB254C405; + y = 64'h380FFFFFFFFFFFBD; + z = 64'hBFDFFFFEFFFE0000; + ans = 64'hBFDFFFFEFFFE0000; rn = 1; rz = 0; rm = 0; @@ -74297,12 +243826,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3182119\n"); + $fwrite(fp,"3184817\n"); + end + x = 64'hDFF000000001FFC0; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3185431\n"); end x = 64'h8000000000000001; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + y = 64'h403FFFFAFFFFFFFF; + z = 64'h3FBFFFFF0000FFFE; + ans = 64'h3FBFFFFF0000FFFE; rn = 1; rz = 0; rm = 0; @@ -74344,12 +243920,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3184133\n"); + $fwrite(fp,"3186045\n"); end - x = 64'hB81F130C997C7900; + x = 64'h3FD00000040000FF; + y = 64'hBFD0000000000001; + z = 64'h3B9FFFFEFFFFFFFD; + ans = 64'hBFB0000004000100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3186659\n"); + end + x = 64'h8000000000000001; + y = 64'h585F840000000000; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3187273\n"); + end + x = 64'h3FE010003FFFFFFF; + y = 64'h3FDCF4E15823EAC4; + z = 64'h40D002000000001F; + ans = 64'h40D0020E88EB56C7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3187887\n"); + end + x = 64'h8000000000000001; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3188501\n"); + end + x = 64'h3FFFFFFFFFC02000; + y = 64'h3FEE000020000000; + z = 64'h3CA0000000000001; + ans = 64'h3FFE00001FC41E00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3189115\n"); + end + x = 64'h8000000000000001; y = 64'hBFE0000000000000; - z = 64'h2F8FFFFFFB800000; - ans = 64'h380F130C997C7900; + z = 64'hCF2FFFFF00080000; + ans = 64'hCF2FFFFF00080000; rn = 1; rz = 0; rm = 0; @@ -74391,12 +244202,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3186147\n"); + $fwrite(fp,"3189729\n"); end - x = 64'hC100007FFFFFFFBF; - y = 64'hB3FFFFFFFFFFFFFE; - z = 64'h36CFFFC00000000E; - ans = 64'h36CFFFC00200100E; + x = 64'hBFCE0B425BCBFB74; + y = 64'hC060000000047FFF; + z = 64'h43D0008000007FFF; + ans = 64'h43D0008000007FFF; rn = 1; rz = 0; rm = 0; @@ -74438,12 +244249,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3188161\n"); + $fwrite(fp,"3190343\n"); + end + x = 64'h480FC00000000006; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3190957\n"); end x = 64'h8000000000000001; - y = 64'hBFF0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + y = 64'h47F1710E4E562E96; + z = 64'hBD4FFFFFF7FFDFFF; + ans = 64'hBD4FFFFFF7FFDFFF; rn = 1; rz = 0; rm = 0; @@ -74485,12 +244343,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3190175\n"); + $fwrite(fp,"3191571\n"); end - x = 64'h439FFDFFFF7FFFFF; - y = 64'hC000000000000000; - z = 64'hBFC00000001FEFFF; - ans = 64'hC3AFFDFFFF7FFFFF; + x = 64'h986A47CFEF9354B1; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hC1FDFFFFFFFFDFFF; + ans = 64'hC1FDFFFFFFFFDFFF; rn = 1; rz = 0; rm = 0; @@ -74532,12 +244390,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3192189\n"); + $fwrite(fp,"3192185\n"); end - x = 64'hBFBFFFFFFFFB7FFF; - y = 64'h40AFFFFFEF000000; - z = 64'h3FD000000000FE00; - ans = 64'hC07FFBFFEEFB7FC0; + x = 64'h8000000000000001; + y = 64'h7FFC6AF03F2EE520; + z = 64'hBFF0000000000001; + ans = 64'h7FFC6AF03F2EE520; rn = 1; rz = 0; rm = 0; @@ -74579,12 +244437,482 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3194203\n"); + $fwrite(fp,"3192799\n"); + end + x = 64'h41D0FFFFFFF00000; + y = 64'hC670400000000010; + z = 64'h802A369C60C3660A; + ans = 64'hC85143FFFFEFC011; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3193413\n"); + end + x = 64'h8000000000000001; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3194027\n"); + end + x = 64'hA89FF00000002000; + y = 64'hC3CF7FFFEFFFFFFF; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h2C7F703FF0081F7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3194641\n"); + end + x = 64'h8000000000000001; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h002E000000100000; + ans = 64'h002E000000100001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3195255\n"); + end + x = 64'hFBACD419571A8A67; + y = 64'hBFB000000007FFF6; + z = 64'hCCFFFFFFFFEBFFFF; + ans = 64'h7B6CD4195728F462; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3195869\n"); + end + x = 64'h402FFFFFEFFFFFFE; + y = 64'hC000000000000001; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3196483\n"); + end + x = 64'h8000000000000001; + y = 64'h41AAD58B6045CD6B; + z = 64'hC10A304B72BC6F6B; + ans = 64'hC10A304B72BC6F6B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3197097\n"); + end + x = 64'h37FA903A0F051747; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h1580001FFFFFFFFA; + ans = 64'hB81A903A0F051746; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3197711\n"); + end + x = 64'h8000000000000001; + y = 64'hBD7000FFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3198325\n"); + end + x = 64'h409FFFFFFE007FFF; + y = 64'hBFF0000800001FFE; + z = 64'hC03FFF7EFFFFFFFF; + ans = 64'hC0A04006FD005F7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3198939\n"); end x = 64'h8000000000000001; y = 64'hC010000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -74626,12 +244954,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3196217\n"); + $fwrite(fp,"3199553\n"); end - x = 64'hCBEFF5E54070F06F; + x = 64'hB7FFFFFFFFFFFFF6; + y = 64'h3F9FFFFFEFFFFFFB; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'hB7AFFFFFEFFFFFF1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3200167\n"); + end + x = 64'h8000000000000001; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h30E0007FF8000000; + ans = 64'h30E0007FF8000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3200781\n"); + end + x = 64'h2403E22FEBFF5C8C; + y = 64'hA2700000001FF000; + z = 64'hFFF2D8FC1EB17C85; + ans = 64'hFFFAD8FC1EB17C85; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3201395\n"); + end + x = 64'h439080FFFFFFFFFE; y = 64'hC340000000000000; - z = 64'h41A0000000001FFD; - ans = 64'h4F3FF5E54070F06F; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'hC6E080FFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -74673,12 +245142,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3198231\n"); + $fwrite(fp,"3202009\n"); end - x = 64'hE24FFFFFFFF7FFFB; - y = 64'hA70FFFEF7FFFFFFF; - z = 64'hC34FFFFFFE00001F; - ans = 64'h496FFFEF7FF7FFFE; + x = 64'h8000000000000001; + y = 64'h4007FFFFDFFFFFFF; + z = 64'hC800000003FFFFFF; + ans = 64'hC800000003FFFFFF; rn = 1; rz = 0; rm = 0; @@ -74720,12 +245189,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3200245\n"); + $fwrite(fp,"3202623\n"); + end + x = 64'h7FEFBFEFFFFFFFFF; + y = 64'hC340000000000001; + z = 64'hBF32430CFD082394; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3203237\n"); + end + x = 64'h8000000000000001; + y = 64'hBFCDCBE729492DEC; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3203851\n"); + end + x = 64'hB97FFFFFFFFFF80F; + y = 64'hBE3FFFFFFFFFFFFF; + z = 64'h43F0001FFFEFFFFF; + ans = 64'h43F0001FFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3204465\n"); + end + x = 64'h8000000000000001; + y = 64'hFFE0000000000000; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3205079\n"); + end + x = 64'h43D1A8D2E24A2428; + y = 64'hC3DFFFE000000020; + z = 64'h0000000000000000; + ans = 64'hC7C1A8C1397741F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3205693\n"); end x = 64'h8000000000000001; y = 64'hFFE0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000003; + z = 64'hC1FFBFFFDFFFFFFE; + ans = 64'hC1FFBFFFDFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -74767,12 +245471,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3202259\n"); + $fwrite(fp,"3206307\n"); end - x = 64'h41E0210000000000; + x = 64'hB76008000FFFFFFF; + y = 64'h41F000000000080F; + z = 64'hC1E5F2F67AF51AB8; + ans = 64'hC1E5F2F67AF51AB8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3206921\n"); + end + x = 64'hEB6FFFF9FFFFFFFE; y = 64'hFFEFFFFFFFFFFFFE; - z = 64'h401FFFFF9FFFFFFE; - ans = 64'hFFF0000000000000; + z = 64'h4010000000000000; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -74814,12 +245565,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3204273\n"); + $fwrite(fp,"3207535\n"); end - x = 64'h43FFFFFFFFF7FFBF; - y = 64'h40107FFFFFFFBFFF; - z = 64'hC01000002000007E; - ans = 64'h44207FFFFFFB9FDD; + x = 64'h8000000000000001; + y = 64'h43DFC007FFFFFFFE; + z = 64'h08BFFEFFC0000000; + ans = 64'h08BFFEFFC0000000; rn = 1; rz = 0; rm = 0; @@ -74861,1562 +245612,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3206287\n"); + $fwrite(fp,"3208149\n"); end - x = 64'h800FFFFFFFFFFFFF; - y = 64'h0000000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3208301\n"); - end - x = 64'h41E3A0AE429A2C7A; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hBFA0000007FFFFBF; - ans = 64'hBFA0000007FFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3210315\n"); - end - x = 64'h41CE90F78950EFF5; - y = 64'h2BC0002001FFFFFF; - z = 64'h47F72050F7B5B781; - ans = 64'h47F72050F7B5B781; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3212329\n"); - end - x = 64'h800FFFFFFFFFFFFF; - y = 64'h3CA0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3214343\n"); - end - x = 64'h00100000013FFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h43E5EB9A245CBACD; - ans = 64'h43E5EB9A245CBACD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3216357\n"); - end - x = 64'hBFBFFFF7FFFFFFFF; - y = 64'hFFFFE00000010000; - z = 64'h245FFFBFFFFFE000; - ans = 64'hFFFFE00000010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3218371\n"); - end - x = 64'h800FFFFFFFFFFFFF; - y = 64'h3FE0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3220385\n"); - end - x = 64'hC090003FFFFFFFFB; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h41D00000003FFE00; - ans = 64'h41CFFFFE0077FC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3222399\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'h5BB0000000FFFFF6; - z = 64'hFFD4FC49106C175B; - ans = 64'hFFD4FC49106C175B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3224413\n"); - end - x = 64'h800FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3226427\n"); - end - x = 64'h3A7FDEFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - z = 64'h3E34007FFFFFFFFF; - ans = 64'h3E34007FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3228441\n"); - end - x = 64'hC0200000000017FF; - y = 64'hC3E07FEFFFFFFFFE; - z = 64'h41637FFFFFFFFFFE; - ans = 64'h44107FF000001B2D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3230455\n"); - end - x = 64'h800FFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3232469\n"); - end - x = 64'h3B9FFFFFF4000000; - y = 64'h4340000000000001; - z = 64'hB9AFF7FFFFFFFEFF; - ans = 64'h3EEFFFFFF4000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3234483\n"); - end - x = 64'hC3E40000000001FF; - y = 64'h40F000003FFF8000; - z = 64'h5FC000007FDFFFFE; - ans = 64'h5FC000007FDFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3236497\n"); - end - x = 64'h800FFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3238511\n"); - end - x = 64'h59300000000083FF; - y = 64'h7FF0000000000001; - z = 64'h3FE000003FFEFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3240525\n"); - end - x = 64'h43C0000400000007; - y = 64'hBFFFFFFDFFFFFDFF; - z = 64'h401FFFFFFFF81FFE; - ans = 64'hC3D00002FFFFBF06; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3242539\n"); - end - x = 64'h800FFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3244553\n"); - end - x = 64'hBFC00000001FFFFF; - y = 64'h8010000000000001; - z = 64'hC08007FFFF7FFFFF; - ans = 64'hC08007FFFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3246567\n"); - end - x = 64'h380531927F4EEF39; - y = 64'h2EC0003FFFFFFC00; - z = 64'hBFC7FFFFFFEFFFFF; - ans = 64'hBFC7FFFFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3248581\n"); - end - x = 64'h800FFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3250595\n"); - end - x = 64'hC010000000000FFA; - y = 64'hBFD0000000000000; - z = 64'h3F60000000200002; - ans = 64'h3FF0080000001FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3252609\n"); - end - x = 64'hC03000000003EFFF; - y = 64'h400FBFFFFFFBFFFF; - z = 64'h704FFFE7FFFFFFFF; - ans = 64'h704FFFE7FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3254623\n"); - end - x = 64'h800FFFFFFFFFFFFF; - y = 64'hBFE0000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3256637\n"); - end - x = 64'h3FD00000FFFFFF80; - y = 64'hBFF0000000000000; - z = 64'hBF6000000020FFFF; - ans = 64'hBFD0200100004180; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3258651\n"); - end - x = 64'h3FCFFFFFFFF7FF7F; - y = 64'hBFF4691AA0D59FCD; - z = 64'h40600007FFE00000; - ans = 64'h405FEBA6E51F2F7B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3260665\n"); - end - x = 64'h800FFFFFFFFFFFFF; - y = 64'hC000000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3262679\n"); - end - x = 64'hBC3A181B260C5619; - y = 64'hC010000000000000; - z = 64'h3816B4ADA3BAD7DB; - ans = 64'h3C5A181B260C5619; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3264693\n"); - end - x = 64'h4010000000000000; - y = 64'hCA32000000008000; - z = 64'h800FFFFFFF00000F; - ans = 64'hCA52000000008000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3266707\n"); - end - x = 64'h800FFFFFFFFFFFFF; - y = 64'hC340000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3268721\n"); - end - x = 64'hA04FFF7FFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'hC0099D723A9AB007; - ans = 64'hC0099D723A9AB007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3270735\n"); - end - x = 64'hFFD03FFFFFFFFFFE; - y = 64'h44A0000000000120; - z = 64'hC08576D5A804F3AE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3272749\n"); - end - x = 64'h800FFFFFFFFFFFFF; + x = 64'hC1FFFFFFE0000400; y = 64'hFFF0000000000000; - z = 64'hBFF0000000000001; + z = 64'h3FF00003C0000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -76459,11 +245659,105 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3274763\n"); + $fwrite(fp,"3208763\n"); end - x = 64'hBFEFE3FFFFFFFFFF; + x = 64'h8000000000000001; + y = 64'hBFDFFFFFF0003FFE; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3209377\n"); + end + x = 64'h6D4BFFFFFFFFFBFF; + y = 64'h3FB000007FE00000; + z = 64'hBFD1FFFFFFFFFFFF; + ans = 64'h6D0C0000DFC7FBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3209991\n"); + end + x = 64'h8000000000000001; y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hB8048124EE8F2256; + z = 64'h3FE0000000000000; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -76506,9693 +245800,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3276777\n"); + $fwrite(fp,"3210605\n"); end - x = 64'h3EEFFF0200000000; - y = 64'hC7EA5C98C43C0BC7; - z = 64'hBF8097B90395D8E2; - ans = 64'hC6EA5BC7853F762A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3278791\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'h0010000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3280805\n"); - end - x = 64'hC050000100003FFF; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h47EFFFC001FFFFFE; - ans = 64'h47EFFFC001FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3282819\n"); - end - x = 64'h7560000001FFFFFE; - y = 64'h3FC1E915AABC5C49; - z = 64'hF5DFC0000FFFFFFF; - ans = 64'hF5DFBB85CA94C19F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3284833\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3286847\n"); - end - x = 64'hC9F0FFFFFFDFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h3F9FFFFFFFF00080; - ans = 64'hC9E0FFFFFFDFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3288861\n"); - end - x = 64'h402ECFB09EFE53B0; - y = 64'h7FDB75E2482305F2; - z = 64'hBE7899D950A5334F; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3290875\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3292889\n"); - end - x = 64'hC3DFFFFF00FFFFFE; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h406003FFFFFFFF7E; - ans = 64'hC3EFFFFF00FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3294903\n"); - end - x = 64'h41F0000003FF7FFF; - y = 64'hD8801FBFFFFFFFFE; - z = 64'h4000028000000000; - ans = 64'hDA801FC004076EFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3296917\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3298931\n"); - end - x = 64'h401FFFFE07FFFFFE; - y = 64'h4010000000000001; - z = 64'hC1F7E00000000000; - ans = 64'hC1F7DFFFFE000020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3300945\n"); - end - x = 64'hC015B720E5BE79F4; - y = 64'hFEFFF7FFFFBFFFFF; - z = 64'h0010001FFFFFFFDF; - ans = 64'h7F25B1B31D599C13; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3302959\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3304973\n"); - end - x = 64'h37FF00003FFFFFFE; - y = 64'h7FE0000000000001; - z = 64'h197A74ED682B8C08; - ans = 64'h77EF000040000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3306987\n"); - end - x = 64'h40100003FFFFFEFE; - y = 64'h402FFFFFF7F7FFFF; - z = 64'hCEAB55D2FAAD3C08; - ans = 64'hCEAB55D2FAAD3C08; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3309001\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3311015\n"); - end - x = 64'hC7FFFFFBFFFFFFF7; - y = 64'h8000000000000001; - z = 64'hC00FFEFFFFFF7FFF; - ans = 64'hC00FFEFFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3313029\n"); - end - x = 64'hBFCBD9490F5D8F7B; - y = 64'h4803FFFFFDFFFFFF; - z = 64'hBF900007FFFF8000; - ans = 64'hC7E167CDA7DCE51B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3315043\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3317057\n"); - end - x = 64'hBF7FFF0000000007; - y = 64'hBCA0000000000000; - z = 64'h381FFFFFFFF7FFE0; - ans = 64'h3C2FFF0000000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3319071\n"); - end - x = 64'h3F8000000000003F; - y = 64'hC1EFFEFFFFFFFFDF; - z = 64'h47E0000400003FFF; - ans = 64'h47E0000400003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3321085\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'hBFD0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3323099\n"); - end - x = 64'hB7FFFEFFFFFFFF7E; - y = 64'hBFE0000000000000; - z = 64'h43FFF7FFFEFFFFFE; - ans = 64'h43FFF7FFFEFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3325113\n"); - end - x = 64'hBF9FF7FFFFFFFFFF; - y = 64'h41E828069D05F676; - z = 64'h401B3ADD2F8A8E68; - ans = 64'hC19821FC8023D7C8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3327127\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'hBFF0000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3329141\n"); - end - x = 64'hC3E0400000000001; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'h002FFC000000007F; - ans = 64'h43F0400000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3331155\n"); - end - x = 64'h3FFFFFFFF8010000; - y = 64'h3CA07FFFFC000000; - z = 64'hB80EFFFFFFEFFFFF; - ans = 64'h3CB07FFFF7E08401; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3333169\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'hC010000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3335183\n"); - end - x = 64'h3FC000000000BFFF; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hBFEFFF9000000000; - ans = 64'hBFFFFFC80000BFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3337197\n"); - end - x = 64'hBFCDFFFFFC000000; - y = 64'hBF5000020001FFFF; - z = 64'h7FFFDFFFFFFFFF7F; - ans = 64'h7FFFDFFFFFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3339211\n"); - end - x = 64'h800FFFFFFFFFFFFE; - y = 64'hFFE0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3341225\n"); - end - x = 64'hB6D007FDFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hBFA7283B2BE5BBEA; - ans = 64'h76D007FDFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3343239\n"); - end - x = 64'h3FD001FFFFFFFFF8; - y = 64'h002FFFFFFF80003F; - z = 64'hBFF1000000400000; - ans = 64'hBFF1000000400000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3345253\n"); - end - x = 64'h8010000000000000; - y = 64'h0000000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3347267\n"); - end - x = 64'h3FB000000800003F; - y = 64'h000FFFFFFFFFFFFF; - z = 64'h3F421EDD58F82BF3; - ans = 64'h3F421EDD58F82BF3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3349281\n"); - end - x = 64'hCFC001007FFFFFFF; - y = 64'hC3DC23821C0039E3; - z = 64'h802FFFFDFFFFFFBF; - ans = 64'h53AC2545353E0AC5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3351295\n"); - end - x = 64'h8010000000000000; - y = 64'h001FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3353309\n"); - end - x = 64'hC1C0000003FFFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h3CA0000000002FFF; - ans = 64'hBE80000003BFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3355323\n"); - end - x = 64'h8024003FFFFFFFFF; - y = 64'h3F008000000007FF; - z = 64'h43F002FFFFFFFFFF; - ans = 64'h43F002FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3357337\n"); - end - x = 64'h8010000000000000; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3359351\n"); - end - x = 64'hFFFDFEFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h3800010000000010; - ans = 64'hFFFDFEFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3361365\n"); - end - x = 64'h43CFFFFFFFFFFFE7; - y = 64'h406FFFFF87FFFFFF; - z = 64'hBFB53C1AA3282811; - ans = 64'h444FFFFF87FFFFE6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3363379\n"); - end - x = 64'h8010000000000000; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3365393\n"); - end - x = 64'h56B01FFFFFFFFF7F; - y = 64'h4000000000000001; - z = 64'h3FC007FFFFFFFFEF; - ans = 64'h56C01FFFFFFFFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3367407\n"); - end - x = 64'hBFE000000BFFFFFF; - y = 64'h3FAFBFFFFC000000; - z = 64'hC7EFFEFF7FFFFFFE; - ans = 64'hC7EFFEFF7FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3369421\n"); - end - x = 64'h8010000000000000; - y = 64'h401FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3371435\n"); - end - x = 64'h2CD0ACC2108D3F7E; - y = 64'h4340000000000001; - z = 64'hB8100001FFFFFFFA; - ans = 64'hB8100001FFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3373449\n"); - end - x = 64'hB891000000000006; - y = 64'h40000000003FF800; - z = 64'h380FFFFFFFFEFFDF; - ans = 64'hB8A0F8000043F7C6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3375463\n"); - end - x = 64'h8010000000000000; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3377477\n"); - end - x = 64'hC80FFFFFFFFF003F; - y = 64'h7FF0000000000000; - z = 64'h7FE0000800000400; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3379491\n"); - end - x = 64'h40375A0C34C4B6A5; - y = 64'h3CAB57AB2349406C; - z = 64'hC0C0000000007FFF; - ans = 64'hC0C0000000007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3381505\n"); - end - x = 64'h8010000000000000; - y = 64'h8000000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3383519\n"); - end - x = 64'h3FD00000000001FA; - y = 64'h8010000000000000; - z = 64'h3FB000000003FFF8; - ans = 64'h3FB000000003FFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3385533\n"); - end - x = 64'hBFB03FFFFFFFFFFB; - y = 64'hFFD0617E96E1DFCD; - z = 64'hB810020000007FFE; - ans = 64'h7F90A304913D6747; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3387547\n"); - end - x = 64'h8010000000000000; - y = 64'hBCA0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3389561\n"); - end - x = 64'hC1DC00FFFFFFFFFF; - y = 64'hBFD0000000000000; - z = 64'hBF8FFFE000001000; - ans = 64'h41BC00FFFFFC0003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3391575\n"); - end - x = 64'hFFD0008800000000; - y = 64'h802B2144A835A75B; - z = 64'h428000000000020F; - ans = 64'h4280000000001D31; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3393589\n"); - end - x = 64'h8010000000000000; - y = 64'hBFE0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3395603\n"); - end - x = 64'h3F80001FFFFEFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'h41DFC10000000000; - ans = 64'h41DFC0FFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3397617\n"); - end - x = 64'hC0000000081FFFFF; - y = 64'hBFE0000400007FFF; - z = 64'h4F9ECE47311DB1DD; - ans = 64'h4F9ECE47311DB1DD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3399631\n"); - end - x = 64'h8010000000000000; - y = 64'hC000000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3401645\n"); - end - x = 64'hC01FFF0000FFFFFF; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'h37AFFFFFFFFF7FFE; - ans = 64'h403FFF0000FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3403659\n"); - end - x = 64'h43F13C60467832BD; - y = 64'hBF902003FFFFFFFE; - z = 64'h6170010000000008; - ans = 64'h6170010000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3405673\n"); - end - x = 64'h8010000000000000; - y = 64'hC340000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3407687\n"); - end - x = 64'hCE17BB7913B68EBE; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'hFFDFFDFFFFFFBFFF; - ans = 64'hFFDFFDFFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3409701\n"); - end - x = 64'hC00FFFFC7FFFFFFF; - y = 64'h3FD7FFFFDFFFFFFF; - z = 64'hBCA000400000000E; - ans = 64'hBFF7FFFD4000037F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3411715\n"); - end - x = 64'h8010000000000000; - y = 64'hFFF0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3413729\n"); - end - x = 64'h3FBFFFFFFF6FFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h7FE0000007FFEFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3415743\n"); - end - x = 64'h3FBFFFFFEFBFFFFF; - y = 64'h3F600001FF7FFFFE; - z = 64'hBFC000FFFFFFFFFE; - ans = 64'hBFBFF1FFFE089FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3417757\n"); - end - x = 64'h8010000000000001; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3419771\n"); - end - x = 64'h41DFFFFFC0FFFFFF; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h3F94000007FFFFFF; - ans = 64'h3F94000007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3421785\n"); - end - x = 64'h3FBFF7FFFFFFFFFD; - y = 64'h47F0203FFFFFFFFE; - z = 64'hC7FFFFFFFE00FFFE; - ans = 64'hC7FDFC790000FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3423799\n"); - end - x = 64'h8010000000000001; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3425813\n"); - end - x = 64'h41EFFFFFFFFF807F; - y = 64'h3FD0000000000001; - z = 64'hC01FEFFFFFFFF7FF; - ans = 64'h41CFFFFFFC018081; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3427827\n"); - end - x = 64'h40BFFFFFFFFC1FFE; - y = 64'hB7F27B1F5CF87205; - z = 64'h43FF080000000000; - ans = 64'h43FF080000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3429841\n"); - end - x = 64'h8010000000000001; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3431855\n"); - end - x = 64'hC077FFFFFFFFFF00; - y = 64'h3FF0000000000001; - z = 64'h0D79996219EE0031; - ans = 64'hC077FFFFFFFFFF01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3433869\n"); - end - x = 64'h4248C62FE782EACE; - y = 64'hC1EFFE0000004000; - z = 64'h41DFFF7FFFFFFFFE; - ans = 64'hC448C4A38484642D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3435883\n"); - end - x = 64'h8010000000000001; - y = 64'h400FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3437897\n"); - end - x = 64'h380CF72099FF042F; - y = 64'h4010000000000001; - z = 64'h43CFFFFEFC000000; - ans = 64'h43CFFFFEFC000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3439911\n"); - end - x = 64'h43D6FD1AAB74AF22; - y = 64'h3FC4000001000000; - z = 64'hC036977D15FCAD7C; - ans = 64'h43ACBC6157C1AC95; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3441925\n"); - end - x = 64'h8010000000000001; - y = 64'h434FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3443939\n"); - end - x = 64'hC02003FFFFFF0000; - y = 64'h7FE0000000000000; - z = 64'hB800925EA3EAE96D; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3445953\n"); - end - x = 64'h800B5BF9E2135023; - y = 64'h41C428A0B2E99933; - z = 64'hC0CFFFFFE00003FF; - ans = 64'hC0CFFFFFE00003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3447967\n"); - end - x = 64'h8010000000000001; - y = 64'h7FF0000000000001; - z = 64'hC340000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3449981\n"); - end - x = 64'h432A225C3E0BC75A; - y = 64'h8000000000000000; - z = 64'h2770000100000002; - ans = 64'h2770000100000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3451995\n"); - end - x = 64'h3F6675CC0F69D0EE; - y = 64'hBE0EFFFFDFFFFFFF; - z = 64'hB80FFFFFFF80FFFF; - ans = 64'hBD85C21D9878B656; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3454009\n"); - end - x = 64'h8010000000000001; - y = 64'h8010000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3456023\n"); - end - x = 64'hC7FA3FE7B36ABE4C; - y = 64'hBCA0000000000000; - z = 64'h9720001FFBFFFFFF; - ans = 64'h44AA3FE7B36ABE4C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3458037\n"); - end - x = 64'hC1FFFC0000000000; - y = 64'h693FFC0100000000; - z = 64'hF41FFFFFFFEEFFFF; - ans = 64'hF41FFFFFFFEEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3460051\n"); - end - x = 64'h8010000000000001; - y = 64'hBFD0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3462065\n"); - end - x = 64'hBDCFE00FFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hBFC000000200000F; - ans = 64'hBFC0000001F01007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3464079\n"); - end - x = 64'hE85BA35844A698B8; - y = 64'h43E000FFFFFBFFFF; - z = 64'h3C050A7780FB23F7; - ans = 64'hEC4BA5127A23FA4A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3466093\n"); - end - x = 64'h8010000000000001; - y = 64'hBFF0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3468107\n"); - end - x = 64'h41100008000FFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'h3FB1BAAC953356D1; - ans = 64'hC1200007DC9AA6D3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3470121\n"); - end - x = 64'h3DFFFF0000001FFF; - y = 64'h406FF08000000000; - z = 64'hC04000000807FFFF; - ans = 64'hC0400000070883FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3472135\n"); - end - x = 64'h8010000000000001; - y = 64'hC010000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3474149\n"); - end - x = 64'h43D0BFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h4020000000087FFE; - ans = 64'hC400BFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3476163\n"); - end - x = 64'h7FF000003FFFFFEF; - y = 64'hB7F8153138E3190F; - z = 64'h3FF000000081FFFE; - ans = 64'h7FF800003FFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3478177\n"); - end - x = 64'h8010000000000001; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3480191\n"); - end - x = 64'h3FFF7FFFFFFBFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'h0680000000FBFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3482205\n"); - end - x = 64'h0000000000000406; - y = 64'h3FFC81D6A5FF2C7A; - z = 64'hC1D0001FFFBFFFFE; - ans = 64'hC1D0001FFFBFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3484219\n"); - end - x = 64'h8010000000000001; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3486233\n"); - end - x = 64'hC3CB352D1CEBDE90; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hBF07D545D95AB53B; - ans = 64'hBF07D545D95AB53B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3488247\n"); - end - x = 64'h00000002FFFFFFFF; - y = 64'hC032140447A137B8; - z = 64'hC000FFFFFBFFFFFE; - ans = 64'hC000FFFFFBFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3490261\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3492275\n"); - end - x = 64'hBF5FFFBFFFFDFFFE; - y = 64'h3CA0000000000001; - z = 64'h3F1FFFFFFE0003FF; - ans = 64'h3F1FFFFFFE0003EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3494289\n"); - end - x = 64'hC7EFFFFFFFFE7FFE; - y = 64'hC1D000FFFFFFF000; - z = 64'h3FE8282441DD2215; - ans = 64'h49D000FFFFFF2FF3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3496303\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3498317\n"); - end - x = 64'h403FFFFFFF801000; - y = 64'h3FE0000000000001; - z = 64'hBFF0803FFFFFFFFF; - ans = 64'h402DEFF7FF801002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3500331\n"); - end - x = 64'hAAA0FFFFBFFFFFFF; - y = 64'hD3CF400000000000; - z = 64'h43400FFFFFFFFFFE; - ans = 64'h43400FFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3502345\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3504359\n"); - end - x = 64'h5E78A4F96ABC9DE7; - y = 64'h4000000000000001; - z = 64'h47F8C8E01D92EAD7; - ans = 64'h5E88A4F96ABC9DE9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3506373\n"); - end - x = 64'hC0D0080000000007; - y = 64'h4011F8543DDEC32B; - z = 64'hC1E712DF030DCD92; - ans = 64'hC1E7130305AE9D8D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3508387\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3510401\n"); - end - x = 64'hC80FFDFFFDFFFFFF; - y = 64'h4340000000000000; - z = 64'h3FC0004200000000; - ans = 64'hCB5FFDFFFDFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3512415\n"); - end - x = 64'h801FFFFFFB800000; - y = 64'h41F3DFFFFFFFFFFF; - z = 64'hB590000002000FFF; - ans = 64'hB590000002000FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3514429\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'h7FE0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hC014000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3516443\n"); - end - x = 64'hC1FFFFFBC0000000; - y = 64'h7FF0000000000000; - z = 64'hC031FFFFFFFFBFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3518457\n"); - end - x = 64'h4800000000020003; - y = 64'h418800000000FFFF; - z = 64'h800468BF093C0C43; - ans = 64'h4998000000040004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3520471\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'h8000000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3522485\n"); - end - x = 64'h462284F38975D0BD; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h3FF0000080001000; - ans = 64'h3FF0000080001000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3524499\n"); - end - x = 64'h3F0B5811E180BC1D; - y = 64'hB800F845914088A3; - z = 64'hC1D507C7637918CE; - ans = 64'hC1D507C7637918CE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3526513\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'hBCA0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3528527\n"); - end - x = 64'h41F0000000002000; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'hBFC1F235F0A8F509; - ans = 64'hBFC1F23DF0A8F509; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3530541\n"); - end - x = 64'hC3C0000010000003; - y = 64'hC343FF7FFFFFFFFF; - z = 64'h0B7FFFFFFFFFFFFF; - ans = 64'h4713FF8013FF8003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3532555\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'hBFE0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3534569\n"); - end - x = 64'hC07FFFFF7FFFFFBF; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hB81000007FFFFF7F; - ans = 64'h407FFFFF7FFFFFBD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3536583\n"); - end - x = 64'h43D5CDB51AEF5A02; - y = 64'hB80FFFFFFFBFFFBF; - z = 64'hC00001FFFFFFFFDE; - ans = 64'hC00001FFFFFFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3538597\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'hC000000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3540611\n"); - end - x = 64'h4340008000007FFF; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h37EFFF7FDFFFFFFF; - ans = 64'hC360008000007FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3542625\n"); - end - x = 64'h403FFFFFFFE0007F; - y = 64'h816FFFFFFFFFFFFE; - z = 64'h41CFFFFFE003FFFF; - ans = 64'h41CFFFFFE003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3544639\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3546653\n"); - end - x = 64'h434FFFFF7FF7FFFF; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'h7FEFFFFFDFFFFFF7; - ans = 64'h7FEFFFFFDFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3548667\n"); - end - x = 64'hC02217A020FC8A2D; - y = 64'h3FA000020000001E; - z = 64'h3FCFFFBFFFFEFFFF; - ans = 64'hBFA0BE131F887378; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3550681\n"); - end - x = 64'h801FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3552695\n"); - end - x = 64'h40A6E61F757B51A4; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'hC04FFFFFFFFFC003; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3554709\n"); - end - x = 64'h406FDFFFFFFFFFF6; - y = 64'h000FFFFC00000002; - z = 64'h48CFDFE000000000; - ans = 64'h48CFDFE000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3556723\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3558737\n"); - end - x = 64'hFFF0008000000008; - y = 64'h0010000000000001; - z = 64'hBFB001000001FFFF; - ans = 64'hFFF8008000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3560751\n"); - end - x = 64'hB49FFDFFDFFFFFFF; - y = 64'h7FFFFFFFFFFE03FF; - z = 64'hCE80000000000020; - ans = 64'h7FFFFFFFFFFE03FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3562765\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3564779\n"); - end - x = 64'hC01913F0B3195632; - y = 64'h3FD0000000000001; - z = 64'h987000000800003F; - ans = 64'hBFF913F0B3195634; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3566793\n"); - end - x = 64'hC00BC65690157317; - y = 64'hC030000000002001; - z = 64'h402D9EB7730C175F; - ans = 64'h40519702366C583F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3568807\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3570821\n"); - end - x = 64'h51013CBA56CFBF70; - y = 64'h3FF0000000000000; - z = 64'hE4603FFFFFFC0000; - ans = 64'hE4603FFFFFFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3572835\n"); - end - x = 64'h277491C48824332E; - y = 64'h401FFFBFFFFDFFFF; - z = 64'hFB3002001FFFFFFF; - ans = 64'hFB3002001FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3574849\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'h4000000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3576863\n"); - end - x = 64'hB80F80000000001E; - y = 64'h4010000000000000; - z = 64'h802FC000000007FE; - ans = 64'hB82F80000000001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3578877\n"); - end - x = 64'h3ABFFFFFFFFF0400; - y = 64'h400FFFFFFAFFFFFF; - z = 64'h37EFE0000000FFFF; - ans = 64'h3ADFFFFFFAFF043F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3580891\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'h4340000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3582905\n"); - end - x = 64'h412F87FFFFFFFFFF; - y = 64'h7FE0000000000000; - z = 64'hBFC3FFFFFFFBFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3584919\n"); - end - x = 64'h6BFFFFFFFF7FFFFC; - y = 64'hEBE9A0EFE851BB03; - z = 64'hC3400001FFBFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3586933\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'h7FF0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3588947\n"); - end - x = 64'hB17EFFDFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hC3F9880289C16CA3; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3590961\n"); - end - x = 64'h41BA9212B83B0240; - y = 64'hFFD00011FFFFFFFF; - z = 64'hBE8AE163BEA821EC; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3592975\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'h8010000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3594989\n"); - end - x = 64'h43F0000000080001; - y = 64'h801FFFFFFFFFFFFE; - z = 64'h380008003FFFFFFE; - ans = 64'h380008003FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3597003\n"); - end - x = 64'h41A33B5BA20B5DF5; - y = 64'hB96FFFFFF7FFFFFE; - z = 64'h800C8FD8F37D3D67; - ans = 64'hBB233B5B9D3C870B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3599017\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'hBFD0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3601031\n"); - end - x = 64'h47E00003FF7FFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hB81FFE0000010000; - ans = 64'hC7D00003FF7FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3603045\n"); - end - x = 64'hB1F0001FFFFDFFFE; - y = 64'hC3F36C0AD01C4C5A; - z = 64'h3F4FFFFF7FFFBFFF; - ans = 64'h3F4FFFFF7FFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3605059\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'hBFF0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3607073\n"); - end - x = 64'hDD40000000FFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h4020CF01046F2F61; - ans = 64'h5D50000000FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3609087\n"); - end - x = 64'hBFF00000000000EF; - y = 64'h37E70C9A6B785725; - z = 64'h47FEFFFFFFFFFFF6; - ans = 64'h47FEFFFFFFFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3611101\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3613115\n"); - end - x = 64'h21779D10D6196833; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'hBFCFFFFFF01FFFFF; - ans = 64'hBFCFFFFFF01FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3615129\n"); - end - x = 64'h630FDFFFDFFFFFFF; - y = 64'hBFE00001FFFFFFFF; - z = 64'hBFFFFFDFEFFFFFFE; - ans = 64'hE2FFE003DBFFFBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3617143\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3619157\n"); - end - x = 64'h37F0100000000200; - y = 64'hFFE0000000000001; - z = 64'h47E2000000003FFE; - ans = 64'hF7E0100000000201; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3621171\n"); - end - x = 64'h4030006000000000; - y = 64'hBFEFFFFFC7FFFFFE; - z = 64'hB229AA56F53BCE04; - ans = 64'hC030005FE3FF57FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3623185\n"); - end - x = 64'h801FFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3625199\n"); - end - x = 64'h3FF5950E99BFD4FF; - y = 64'h0000000000000001; - z = 64'hB82E3E751A766B11; - ans = 64'hB82E3E751A766B11; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3627213\n"); - end - x = 64'hCACFFFFFFFFEFFF6; - y = 64'h3FE000000000803F; - z = 64'h3F7153B79F878E9B; - ans = 64'hCAC000000000003A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3629227\n"); - end - x = 64'hBCA0000000000000; - y = 64'h001FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3631241\n"); - end - x = 64'h3FE68CC51B1C1FB7; - y = 64'h3CA0000000000001; - z = 64'h19C05D99BA276601; - ans = 64'h3C968CC51B1C1FB8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3633255\n"); - end - x = 64'hBB60000000000000; - y = 64'h400FFBFFFFFFFFFC; - z = 64'h380FF80000020000; - ans = 64'hBB7FFBFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3635269\n"); - end - x = 64'hBCA0000000000000; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3637283\n"); - end - x = 64'h43F7AD836D8C6D79; - y = 64'h3FE0000000000000; - z = 64'h801FDFF800000000; - ans = 64'h43E7AD836D8C6D79; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3639297\n"); - end - x = 64'hBCAFFC000000FFFE; - y = 64'h41EFE02000000000; - z = 64'h7FD00000100001FF; - ans = 64'h7FD00000100001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3641311\n"); - end - x = 64'hBCA0000000000000; - y = 64'h3FF0000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3643325\n"); - end - x = 64'hAA84000100000000; - y = 64'h4000000000000000; - z = 64'hC800000000010100; - ans = 64'hC800000000010100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3645339\n"); - end - x = 64'h38402D46BA126A9F; - y = 64'h47E285F845923FD5; - z = 64'h5CC0010020000000; - ans = 64'h5CC0010020000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3647353\n"); - end - x = 64'hBCA0000000000000; - y = 64'h4010000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3649367\n"); - end - x = 64'hD90EFFFFFFFFEFFE; - y = 64'h4340000000000000; - z = 64'h80102000FFFFFFFF; - ans = 64'hDC5EFFFFFFFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3651381\n"); - end - x = 64'hB7F04000003FFFFF; - y = 64'h7FD0FFFFFFE00000; - z = 64'h40CFD1C5180ACEAB; - ans = 64'hF7D1440000237FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3653395\n"); - end - x = 64'hBCA0000000000000; - y = 64'h7FE0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFC90000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3655409\n"); - end - x = 64'hC01A726A4A3AC5D3; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hBFE000000000020F; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3657423\n"); - end - x = 64'h4031000000008000; - y = 64'hC7F400000000FFFF; - z = 64'h43D184BDDA67AC33; - ans = 64'hC83540000001AFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3659437\n"); - end - x = 64'hBCA0000000000000; - y = 64'h8000000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3661451\n"); - end - x = 64'h0BF000008000007F; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h3207A5FB27F86F0F; - ans = 64'h3207A5FB27F86F0F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3663465\n"); - end - x = 64'hCF80007FBFFFFFFF; - y = 64'hFFDFDFFFFF7FFFFF; - z = 64'hF0BED0A6285C8414; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3665479\n"); - end - x = 64'hBCA0000000000000; - y = 64'hBCA0000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3667493\n"); - end - x = 64'hCB000000000000F8; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'h4F30040000100000; - ans = 64'h4F30040000100000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3669507\n"); - end - x = 64'hC020000027FFFFFE; - y = 64'h6EFFFFFFFFFF8003; - z = 64'h4013D748E0532C46; - ans = 64'hEF30000027FFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3671521\n"); - end - x = 64'hBCA0000000000000; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3673535\n"); - end - x = 64'hC7F0FAF5DCDF1C46; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hBFD000000003FFFB; - ans = 64'h47F0FAF5DCDF1C45; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3675549\n"); - end - x = 64'h76C453FC3A9FC346; - y = 64'h47D00FC000000000; - z = 64'h7FDECA60D8A5DECB; - ans = 64'h7FDECA6365A5BBA8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3677563\n"); - end - x = 64'hBCA0000000000000; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hB960000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3679577\n"); - end - x = 64'hCC80000FFE000000; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'hD9BA017626C9D9C9; - ans = 64'hD9BA017626C9D9C9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3681591\n"); - end - x = 64'h3FD0108000000000; - y = 64'h5EA627EA240A0174; - z = 64'hCA1000000008007E; - ans = 64'h5E863EC34D7F2BC5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3683605\n"); - end - x = 64'hBCA0000000000000; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3685619\n"); - end - x = 64'hBED470C16CA5A9A9; - y = 64'hC340000000000001; - z = 64'h3FD0020000000008; - ans = 64'h422470C16CA629BA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3687633\n"); - end - x = 64'hE987FFE000000000; - y = 64'h3FEFFFFFFC00003E; - z = 64'hA0EB2EA4CE828FBC; - ans = 64'hE987FFDFFD00042E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3689647\n"); - end - x = 64'hBCA0000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'h7C9FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3691661\n"); - end - x = 64'h3FE00000040000FF; - y = 64'hFFF0000000000001; - z = 64'h403E6153BAC38ACC; + x = 64'hC291007FFFFFFFFF; + y = 64'hBF200114E0E1C872; + z = 64'hFFF0000000000001; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -86235,12 +245847,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3693675\n"); + $fwrite(fp,"3211219\n"); end - x = 64'h0000000000003FFF; - y = 64'hC346F75321C70778; - z = 64'hBFFFFFFFFFFF9FFF; - ans = 64'hBFFFFFFFFFFF9FFF; + x = 64'h800FFFFFFFFFFFFF; + y = 64'h0000000000000000; + z = 64'hC1DFFFFFFFF7FFFB; + ans = 64'hC1DFFFFFFFF7FFFB; rn = 1; rz = 0; rm = 0; @@ -86282,10 +245894,5838 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3695689\n"); + $fwrite(fp,"3211833\n"); end - x = 64'hBCA0000000000001; + x = 64'hBFF410E3E7C9D4AF; + y = 64'hB98000003FFFBFFE; + z = 64'h3FEFFFFFFFF80080; + ans = 64'h3FEFFFFFFFF80080; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3212447\n"); + end + x = 64'h3FAC000000000020; y = 64'h000FFFFFFFFFFFFF; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3213061\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h801FFFE800000000; + z = 64'hC3CFFFFFFE000010; + ans = 64'hC3CFFFFFFE000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3213675\n"); + end + x = 64'h39D062BBD0CEA065; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h55F10AD99CB7744A; + ans = 64'h55F10AD99CB7744A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3214289\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3816EC8373D1D7C4; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3214903\n"); + end + x = 64'h37EFFFFFFF7FFF7F; + y = 64'hC0AFFFFFFFFC0020; + z = 64'hCF5FFF0000000007; + ans = 64'hCF5FFF0000000007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3215517\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3216131\n"); + end + x = 64'hBFC8A99A7068420A; + y = 64'hC63FFFFEFFBFFFFF; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3216745\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h409FFFDFFFFFFEFF; + ans = 64'h409FFFDFFFFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3217359\n"); + end + x = 64'hB30F00000000007F; + y = 64'hC03FFFFFFFFFFFF3; + z = 64'hBFF0010000400000; + ans = 64'hBFF0010000400000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3217973\n"); + end + x = 64'h41D3FFFFFFFFFFFC; + y = 64'h3CA0000000000001; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h4000000013FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3218587\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC02704BE5CEB7478; + z = 64'h47F0000FFFFFFFDF; + ans = 64'h47F0000FFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3219201\n"); + end + x = 64'hC01D83A25A3526E3; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC80FFFFFBFFFFFF7; + ans = 64'hC80FFFFFBFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3219815\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hBF903FEFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h801FBF003FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3220429\n"); + end + x = 64'h40800005FFFFFFFF; + y = 64'h3FBFFFFF5FFFFFFF; + z = 64'hC46FFFFFFFF87FFE; + ans = 64'hC46FFFFFFFF87FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3221043\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3FD0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3221657\n"); + end + x = 64'h002FFFF00003FFFF; + y = 64'hBCEFFFFFFF6FFFFE; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3222271\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hBF30040003FFFFFF; + ans = 64'hBF30040003FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3222885\n"); + end + x = 64'hBE402FFFFFFFFFFF; + y = 64'h4DC0000FF7FFFFFE; + z = 64'h480FB7FFFFFFFFFE; + ans = 64'hCC10301027E7FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3223499\n"); + end + x = 64'h66B0000020003FFE; + y = 64'h3FE0000000000000; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h66A0000020003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3224113\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC3FF800000000006; + z = 64'h582FFFF001000000; + ans = 64'h582FFFF001000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3224727\n"); + end + x = 64'h41F1FBFFFFFFFFFE; + y = 64'h3FE0000000000001; + z = 64'hBAAFC00000000800; + ans = 64'h41E1FBFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3225341\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC9E000000FFFEFFF; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h0A0000000FFFEFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3225955\n"); + end + x = 64'h3FC4D5E06C217663; + y = 64'h3FEFFFFBFFFEFFFF; + z = 64'hBFE26C4F295F227E; + ans = 64'hBFDA6DAF6A0BE3E4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3226569\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3FF0000000000000; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h000FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3227183\n"); + end + x = 64'hC03FFFFFFFE7FFFE; + y = 64'h41EF800000020000; + z = 64'hC340000000000000; + ans = 64'hC340000FBFFFFFF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3227797\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3FF0000000000001; + z = 64'h3F6FF3FFFFFFFFFF; + ans = 64'h3F6FF3FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3228411\n"); + end + x = 64'h800FFFFFFFDDFFFF; + y = 64'hC7EFFFDFFFFF7FFF; + z = 64'hC0381267393B2AC0; + ans = 64'hC0381267393B2AC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3229025\n"); + end + x = 64'hC3C28B314BB3DDF5; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h3FE0000000000000; + ans = 64'hC3D28B314BB3DDF4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3229639\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC00000007FFFDFFF; + z = 64'hBFCFBFFBFFFFFFFE; + ans = 64'hBFCFBFFBFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3230253\n"); + end + x = 64'hC1DFFFDFFFE00000; + y = 64'h4000000000000000; + z = 64'hBFE6B54C63D18D14; + ans = 64'hC1EFFFDFFFF6B54C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3230867\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC0E0000400FFFFFE; + z = 64'h8000000000000000; + ans = 64'h0100000400FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3231481\n"); + end + x = 64'hC020000000021FFF; + y = 64'h381000000005FFFE; + z = 64'h403FFF8001FFFFFF; + ans = 64'h403FFF8001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3232095\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h0010000000000000; + ans = 64'h8027FFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3232709\n"); + end + x = 64'h1DCC4CEF5FBE077C; + y = 64'hC19F001FFFFFFFFE; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3233323\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h4010000000000000; + z = 64'hC3F0000000200100; + ans = 64'hC3F0000000200100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3233937\n"); + end + x = 64'h0020000200000000; + y = 64'h3FF001FFFFFFFF7F; + z = 64'h418FAFFFFFFFFFFE; + ans = 64'h418FAFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3234551\n"); + end + x = 64'h6B1FFFFFFFFFFF87; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3FD0000000000001; + ans = 64'h6B4FFFFFFFFFFF86; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3235165\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hBE201FBFFFFFFFFE; + z = 64'h43399FFC4505CB9F; + ans = 64'h43399FFC4505CB9F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3235779\n"); + end + x = 64'hC7F000001FFFFDFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hBCA008000003FFFE; + ans = 64'hC82000001FFFFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3236393\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h40E02F860C526F0C; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3237007\n"); + end + x = 64'h3FD000000000040F; + y = 64'hC02BC23F1AA21C79; + z = 64'hC3030C02BE2724D5; + ans = 64'hC3030C02BE2724F1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3237621\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h0000000000000001; + ans = 64'h836FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3238235\n"); + end + x = 64'hBFC9124AC36DEE47; + y = 64'hC40DC17423A58077; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'h43E7502512430022; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3238849\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h067FFFFF00000000; + ans = 64'h067FFFFEFFFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3239463\n"); + end + x = 64'hBF900001FFFFE000; + y = 64'hBFCCDA9EA48F1915; + z = 64'hC06FEFFFFFFFEFFF; + ans = 64'hC06FEFE3255DB01C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3240077\n"); + end + x = 64'hCAAF062EF62EA325; + y = 64'h7FE0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3240691\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h401FFF800001FFFF; + z = 64'h4003C8CC6DA57FC4; + ans = 64'h4003C8CC6DA57FC4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3241305\n"); + end + x = 64'hC360000002040000; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h3ECFFFFFFDFFFF7F; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3241919\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3FD1000000FFFFFF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3242533\n"); + end + x = 64'hB81FFFFFFF7FFDFF; + y = 64'hC01F77FFFFFFFFFF; + z = 64'h4181B4443EED7538; + ans = 64'h4181B4443EED7538; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3243147\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h7FF0000000000000; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3243761\n"); + end + x = 64'h3D9502F76012BACF; + y = 64'h3FC19288FA52ABC7; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFF474; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3244375\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h4006369F85AFF3DB; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3244989\n"); + end + x = 64'h43500000000007DF; + y = 64'h3E7F800004000000; + z = 64'h271FFFFFFFFFFFFF; + ans = 64'h41DF800004000F7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3245603\n"); + end + x = 64'h400FFFEF00000000; + y = 64'h8000000000000000; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h001FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3246217\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h38136AC1C6F3DA6D; + z = 64'hC3D0000000000000; + ans = 64'hC3D0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3246831\n"); + end + x = 64'hC0AF0000FFFFFFFE; + y = 64'h8000000000000001; + z = 64'hCBBF9EF686B069CF; + ans = 64'hCBBF9EF686B069CF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3247445\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h41C003FFFFFBFFFF; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3248059\n"); + end + x = 64'hBFDD4485F626299F; + y = 64'hBFC0000000100FFF; + z = 64'h2C203FFFDFFFFFFF; + ans = 64'h3FAD4485F6438B68; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3248673\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3249287\n"); + end + x = 64'h001FFFFFF7FFFFEE; + y = 64'hC01DFFFFFFFFFFFD; + z = 64'hBFF0000000000000; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3249901\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h8010000000000001; + z = 64'hC0632F971E01269A; + ans = 64'hC0632F971E01269A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3250515\n"); + end + x = 64'hC070000008000800; + y = 64'hC3F5AE6BDDD0E4AC; + z = 64'hBFBA87175AC889D8; + ans = 64'h4475AE6BE8A82572; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3251129\n"); + end + x = 64'hAC6158E30C284003; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h0010000000000000; + ans = 64'h0010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3251743\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3FE1A16DB80FAC6F; + z = 64'h47FE44C8F9A9F8E7; + ans = 64'h47FE44C8F9A9F8E7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3252357\n"); + end + x = 64'hC0F2000000004000; + y = 64'hBCA0000000000000; + z = 64'h38100007E0000000; + ans = 64'h3DA2000000004000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3252971\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h4710200000200000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3253585\n"); + end + x = 64'hC2C2003FFFFFFFFF; + y = 64'h43F003FFFFFFFDFF; + z = 64'h47EFFC0000000000; + ans = 64'h47EFFBFB7ECFFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3254199\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3254813\n"); + end + x = 64'hC1D000000003FFFE; + y = 64'hC03000FF7FFFFFFF; + z = 64'hBFE0000000000001; + ans = 64'h421000FF8002003D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3255427\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hBFD0000000000000; + z = 64'h37E68BA030530633; + ans = 64'h37E68BA030530633; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3256041\n"); + end + x = 64'hFFDE1BB9448ED97D; + y = 64'hC1F7FFFFFBFFFFFE; + z = 64'h3F2FFF001FFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3256655\n"); + end + x = 64'h41EFFFFFEFFBFFFE; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h0000000000000001; + ans = 64'hC1DFFFFFEFFBFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3257269\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hB8154E3AC4D65B24; + z = 64'h7FEFFFBFFFFFFFF8; + ans = 64'h7FEFFFBFFFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3257883\n"); + end + x = 64'hC03FFFFF9FFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h7FF1A6DF1C455395; + ans = 64'h7FF9A6DF1C455395; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3258497\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hE41FB4561FAB2216; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3259111\n"); + end + x = 64'h3979F06890CEA607; + y = 64'h43DFFFF000FFFFFF; + z = 64'h3E0020001FFFFFFF; + ans = 64'h3E00267C36E65A77; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3259725\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hBFE0000000000001; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3260339\n"); + end + x = 64'h381DFFDFFFFFFFFE; + y = 64'hDE8FBFFFFFFF7FFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hD6BDC3E03FFF87FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3260953\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h3E59CC299DB7AD28; + ans = 64'h3E59CC299DB7AD28; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3261567\n"); + end + x = 64'hC0357882E409903D; + y = 64'h413F000200000000; + z = 64'h3FF0000000FFFFDF; + ans = 64'hC184CCC01C7171FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3262181\n"); + end + x = 64'hC04F7439462990DF; + y = 64'hBFF0000000000000; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3262795\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC1C0000401FFFFFF; + z = 64'h49FEFFFFFFFFEFFF; + ans = 64'h49FEFFFFFFFFEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3263409\n"); + end + x = 64'h3E7FFFFFFEFC0000; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h41C0EA1AD0C683E5; + ans = 64'h41C0EA1AD0C683E3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3264023\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3FDCE1B5FD249CA2; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3264637\n"); + end + x = 64'h4D70000080000200; + y = 64'hB815E6661713B195; + z = 64'hC270400000000006; + ans = 64'hC595E666C646E50E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3265251\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC000000000000000; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3265865\n"); + end + x = 64'hBFF0000000013FFF; + y = 64'h0010000000800002; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3266479\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hBC0FFFFFFFFBDFFF; + ans = 64'hBC0FFFFFFFFBDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3267093\n"); + end + x = 64'h43F1400000000000; + y = 64'h7FF1FFFFFFFFF7FF; + z = 64'hC03376A99788577F; + ans = 64'h7FF9FFFFFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3267707\n"); + end + x = 64'hC03FFFFEFFFC0000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3268321\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3CA9266BE80A93FD; + z = 64'h3FE0000000000002; + ans = 64'h3FE0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3268935\n"); + end + x = 64'h3E40000000002800; + y = 64'hC010000000000001; + z = 64'hC1FFCEF695EE509D; + ans = 64'hC1FFCEF695EE509D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3269549\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h43D0000001F7FFFF; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3270163\n"); + end + x = 64'h40100001FFFFFFFA; + y = 64'h268FFC000000FFFF; + z = 64'hC7FBC385A0705522; + ans = 64'hC7FBC385A0705522; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3270777\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3271391\n"); + end + x = 64'h5BC00000000001FB; + y = 64'hC32FF769DD7FB534; + z = 64'hBCA0000000000000; + ans = 64'hDEFFF769DD7FB929; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3272005\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC340000000000001; + z = 64'h37F3BB17F4F23CA5; + ans = 64'h37F3BB17F4F23CA5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3272619\n"); + end + x = 64'hC1C16F9BFFD282C8; + y = 64'h402FFF8000000007; + z = 64'hAF200807FFFFFFFF; + ans = 64'hC2016F5641628382; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3273233\n"); + end + x = 64'h001FFFFFFFFFF0FF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3273847\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h0011FE8BFC8537FA; + z = 64'hBD5FFFFFFFF7FFFE; + ans = 64'hBD5FFFFFFFF7FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3274461\n"); + end + x = 64'hC2E0002000000040; + y = 64'hFFE0000000000000; + z = 64'h435AC2FE89704E9A; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3275075\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h7FF7FFFFDFFFFFFF; + z = 64'h3FF0000000000000; + ans = 64'h7FFFFFFFDFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3275689\n"); + end + x = 64'h444FFFFA00000000; + y = 64'hC49FDFFFBFFFFFFE; + z = 64'h491FFFFFFFFEFFFF; + ans = 64'h491808018E7EFCFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3276303\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hC000000000000000; + ans = 64'h3FFFFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3276917\n"); + end + x = 64'h3FE7F167081042E5; + y = 64'hACCFFFFFFBFF8000; + z = 64'h8010000000000001; + ans = 64'hACC7F1670511B63E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3277531\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hFFF0000000000000; + z = 64'h3A2000007FFFFBFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3278145\n"); + end + x = 64'hBF8FFFFFFFC01000; + y = 64'h001FEFFFFFFFFFFC; + z = 64'h396FFFFFFFFFFC7F; + ans = 64'h396FFFFFFFFFFC7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3278759\n"); + end + x = 64'h37EFF0F499363D92; + y = 64'hFFF0000000000001; + z = 64'hC340000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3279373\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'h43EFFFF7FFFFFFFD; + z = 64'h412E65857660BD6A; + ans = 64'h412E65857660BD6A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3279987\n"); + end + x = 64'h3D8FFF7FFFEFFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h8010FFFF7FFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3280601\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h000FFF0000001FFE; + z = 64'h3FE0000000000001; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3281215\n"); + end + x = 64'h457F003FFFFFFFFF; + y = 64'h3F40000000000102; + z = 64'h002C04D8F9B9A9E4; + ans = 64'h44CF0040000001F3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3281829\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h0000000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3282443\n"); + end + x = 64'h4A0FFFFFFFFCFFFE; + y = 64'h37FFFFFFFF040000; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h421FFFFFFF00FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3283057\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h001000000FFFFBFE; + ans = 64'h001000000FFFFBFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3283671\n"); + end + x = 64'h800FFDFFFFFFFBFF; + y = 64'hBFAFDFFFF7FFFFFE; + z = 64'hBF11000000000400; + ans = 64'hBF11000000000400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3284285\n"); + end + x = 64'hC1F0001FFFFFBFFF; + y = 64'h0010000000000000; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3284899\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h40403FFFFFFFFFFD; + z = 64'hAB0FDFFFFFFFFDFF; + ans = 64'hAB0FDFFFFFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3285513\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h480FC40000000000; + ans = 64'h480FC40000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3286127\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h80070F523EA30032; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3286741\n"); + end + x = 64'hC100FFFFFFFFEFFF; + y = 64'h7FFF83FFFFFFFFFE; + z = 64'hA2DFFFFFBFFFFFE0; + ans = 64'h7FFF83FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3287355\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h3CA0000000000000; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3287969\n"); + end + x = 64'h43DFFFFFFF0003FF; + y = 64'h42FA8B901194A63F; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -86329,12 +251769,5088 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3697703\n"); + $fwrite(fp,"3288583\n"); end - x = 64'h42409BDB0E8B5BAC; + x = 64'h800FFFFFFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC7E80000001FFFFF; + ans = 64'hC7E80000001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3289197\n"); + end + x = 64'h000FF00000001000; + y = 64'h41EFFFFFFFFFFCFF; + z = 64'h43FFFFFFBFC00000; + ans = 64'h43FFFFFFBFC00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3289811\n"); + end + x = 64'h3FFFA9456A66B8C6; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3290425\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h35CFFFFBFFFFFFFE; + z = 64'h43F00800003FFFFE; + ans = 64'h43F00800003FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3291039\n"); + end + x = 64'h7FEEA44E583282BA; + y = 64'h3FD0000000000001; + z = 64'h404FFFF7FFFBFFFF; + ans = 64'h7FCEA44E583282BC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3291653\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hB480000000000FF7; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3292267\n"); + end + x = 64'h3E2FFFFF80003FFF; + y = 64'h4030FFFFFFFFFFFF; + z = 64'hC44FBFFFFFFFFFF7; + ans = 64'hC44FBFFFFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3292881\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3293495\n"); + end + x = 64'hB2CFFF8000000001; + y = 64'hB88FFFFFFFFDF000; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3294109\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h3FE0000000000001; + z = 64'h0010000400000010; + ans = 64'h0008000400000011; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3294723\n"); + end + x = 64'h3F907FFF00000000; + y = 64'h40500007FFFFE000; + z = 64'hC1DFFFFFFFE04000; + ans = 64'hC1DFFFFFFF9E3FE3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3295337\n"); + end + x = 64'hB3300007FDFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3295951\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hC00619E1A258A831; + z = 64'h434FDFFC00000000; + ans = 64'h434FDFFC00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3296565\n"); + end + x = 64'h002F0007FFFFFFFE; + y = 64'h3FF0000000000000; + z = 64'h40C0000003FFFFFC; + ans = 64'h40C0000003FFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3297179\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h801FFFF7FBFFFFFE; + z = 64'h3CA0000000000000; + ans = 64'h3CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3297793\n"); + end + x = 64'hB27102DF0BD0BADE; + y = 64'hA57FFFFFA0000000; + z = 64'hBA727FFFFFFFFFFE; + ans = 64'hBA727FFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3298407\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3299021\n"); + end + x = 64'hBFB9F8E9AE43667C; + y = 64'hB7FFFE00000003FE; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3299635\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h4000000000000000; + z = 64'h405000027FFFFFFF; + ans = 64'h405000027FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3300249\n"); + end + x = 64'hC0103FDFFFFFFFFF; + y = 64'h5D1000001000000F; + z = 64'hAE6CFD66D57C4A6B; + ans = 64'hDD303FE0103FE00E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3300863\n"); + end + x = 64'h3FE00203FFFFFFFF; + y = 64'h4000000000000001; + z = 64'hBFF0000000000001; + ans = 64'h3F401FFFFFFFF801; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3301477\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h3850000007FFFFFC; + z = 64'h41E8000000004000; + ans = 64'h41E8000000004000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3302091\n"); + end + x = 64'hAA7000000010FFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h0FE000400007FFFF; + ans = 64'hAA9000000010FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3302705\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h001FBFFFFFBFFFFE; + z = 64'h0010000000000001; + ans = 64'h0010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3303319\n"); + end + x = 64'h3ED0000000C00000; + y = 64'h3FDBCD5857809B86; + z = 64'hC03BFFFFFF7FFFFF; + ans = 64'hC03BFFFFE3B2A7A6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3303933\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h4010000000000001; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3304547\n"); + end + x = 64'hC2FFFFFFBFFFBFFE; + y = 64'h404FFFFFE1FFFFFF; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'hC34FFFFF43FF8073; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3305161\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h43CFFFFFFFFFEFFE; + ans = 64'h43CFFFFFFFFFEFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3305775\n"); + end + x = 64'hFFE0020000003FFF; + y = 64'hBF40000000FFFFFC; + z = 64'h0000003FFDFFFFFF; + ans = 64'h7F30020001005FFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3306389\n"); + end + x = 64'h41E0000010004000; + y = 64'h4340000000000000; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'h4530000010004000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3307003\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hBD3FFFFC0000007F; + z = 64'h3FDFFFFFBFFFFDFF; + ans = 64'h3FDFFFFFBFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3307617\n"); + end + x = 64'h434A579E176B14FB; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h43EFFFFFFF7FFFFE; + ans = 64'h46AA579E176B16FA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3308231\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h3FD0000000007FFE; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h000BFFFFFFFFE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3308845\n"); + end + x = 64'h47F0000007FC0000; + y = 64'hC5C08003FFFFFFFF; + z = 64'hB68FFEFFFFFDFFFF; + ans = 64'hCDC08004083BE1FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3309459\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h7FE0000000000000; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3310073\n"); + end + x = 64'h400EEFFFFFFFFFFF; + y = 64'hBF1FFDFFFFFFE000; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFF8447BBFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3310687\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h3CA5272068BFA9C0; + ans = 64'hC00FFFFFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3311301\n"); + end + x = 64'h4A5FFFFFFFFDFEFF; + y = 64'hC1DFFFFFFFBDFFFF; + z = 64'hC1EFC0000000003F; + ans = 64'hCC4FFFFFFFBBFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3311915\n"); + end + x = 64'h419007FFFFFFFFBF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3312529\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h9FBCFFFFFFFFFFFF; + z = 64'hADE01FF7FFFFFFFF; + ans = 64'hADE01FF7FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3313143\n"); + end + x = 64'hBFFCF103D80A58EE; + y = 64'h7FF0000000000001; + z = 64'hB7F8B48F2C8A4C4D; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3313757\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h66AFFFFFFFFFBFEF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3314371\n"); + end + x = 64'h3FBFFFE000000100; + y = 64'h401FED37CFC20DEA; + z = 64'hC10000000000027F; + ans = 64'hC0FFFFF0097413B9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3314985\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3315599\n"); + end + x = 64'h414FFFC007FFFFFF; + y = 64'hDC73D5385DFE4F27; + z = 64'h4010000000000000; + ans = 64'hDDD3D510B882E141; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3316213\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h8000000000000001; + z = 64'h403FFFFFFFFEFFEF; + ans = 64'h403FFFFFFFFEFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3316827\n"); + end + x = 64'hFFD000008000007F; + y = 64'hC0099588A9B1AE8D; + z = 64'h3D5F81AF27B7463A; + ans = 64'h7FE99589765DF4A6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3317441\n"); + end + x = 64'h47EFFFFF7FFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3318055\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h3D3FDFFFFFFFC000; + z = 64'hE7800010FFFFFFFE; + ans = 64'hE7800010FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3318669\n"); + end + x = 64'h3E0F7FBFFFFFFFFE; + y = 64'h8010000000000000; + z = 64'hC010FF7FFFFFFFFF; + ans = 64'hC010FF7FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3319283\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hC500000007FFFFFA; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3319897\n"); + end + x = 64'hC1EFFFFFFF080000; + y = 64'hB7FF4C5FEC06BFEE; + z = 64'hC3FB1197B5C63C71; + ans = 64'hC3FB1197B5C63C71; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3320511\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h8000000000000000; + ans = 64'h0000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3321125\n"); + end + x = 64'hCD3EFFFFFFFFFC00; + y = 64'hC7E10000000FFFFF; + z = 64'h4000000000000001; + ans = 64'h55307800000F7DDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3321739\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hBCA0000000000000; + z = 64'h3FE01FFFDFFFFFFF; + ans = 64'h3FE01FFFDFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3322353\n"); + end + x = 64'hC0F0000000F7FFFF; + y = 64'hC1DF7FEFFFFFFFFE; + z = 64'h4E2E00000000003F; + ans = 64'h4E2E00000000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3322967\n"); + end + x = 64'h43C3FFFFFFC00000; + y = 64'hBCA0000000000001; + z = 64'hBCA0000000000001; + ans = 64'hC073FFFFFFC00001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3323581\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h43DFFFFFFFFE000F; + z = 64'hC3C000000FF80000; + ans = 64'hC3C000000FF80000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3324195\n"); + end + x = 64'h8020800000000008; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBFC0800000000001; + ans = 64'hBFC0800000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3324809\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h4349D797CF3BC3F4; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3325423\n"); + end + x = 64'hBF9000007EFFFFFF; + y = 64'h4348DF378B8A6FE1; + z = 64'hCE00001FFFFFFFF7; + ans = 64'hCE00001FFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3326037\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hBFD0000000000001; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3326651\n"); + end + x = 64'hB5CFFFFBFF7FFFFF; + y = 64'h3FF0000000200000; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3327265\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h3B9FFFFE02000000; + ans = 64'h3B9FFFFE02000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3327879\n"); + end + x = 64'hBFFFFFFE20000000; + y = 64'h4DD00007FFFF7FFE; + z = 64'hB93E9C46925C398F; + ans = 64'hCDE000070FFF07FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3328493\n"); + end + x = 64'hBFCFFE0000000100; + y = 64'hBFE0000000000000; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h3FBFFE0000000100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3329107\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hBFE0000003FFFFFF; + z = 64'hC1CFFFFFFF7E0000; + ans = 64'hC1CFFFFFFF7E0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3329721\n"); + end + x = 64'hC7E0000103FFFFFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hC3FFEFFFFEFFFFFF; + ans = 64'h47E0000103FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3330335\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h8020000803FFFFFE; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3330949\n"); + end + x = 64'hB0D06C48D23CE86B; + y = 64'hC1C73954256DB898; + z = 64'h47F9EFC1D9AD8521; + ans = 64'h47F9EFC1D9AD8521; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3331563\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hBFF0000000000000; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3332177\n"); + end + x = 64'hC7EFFFDFFFFDFFFF; + y = 64'hC98FE00000000000; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h518FDFE01FFE01FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3332791\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hBFF0000000000001; + z = 64'h94D020000000001F; + ans = 64'h94D020000000001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3333405\n"); + end + x = 64'hC0300800003FFFFE; + y = 64'h8001FFFFF7FFFFFF; + z = 64'hC1D075BF2C245F2A; + ans = 64'hC1D075BF2C245F2A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3334019\n"); + end + x = 64'h400F6470568463BB; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hC01F6470568463B9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3334633\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hBFDF31A46F1F02A3; + z = 64'hBFB0FFFFFFFFFFF7; + ans = 64'hBFB0FFFFFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3335247\n"); + end + x = 64'hC01000000017FFFE; + y = 64'hC000000000000001; + z = 64'hEBAFFFFFFFE0003F; + ans = 64'hEBAFFFFFFFE0003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3335861\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h7FF0ECF8BC191E65; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'h7FF8ECF8BC191E65; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3336475\n"); + end + x = 64'h7FFFFFFFFFFFFEF7; + y = 64'hCABFF7FFFFFFFFE0; + z = 64'h7FD00001FFFF7FFE; + ans = 64'h7FFFFFFFFFFFFEF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3337089\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3337703\n"); + end + x = 64'hC3C077FFFFFFFFFF; + y = 64'h8000000000002010; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3338317\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hC010000000000000; + z = 64'h800DFEDE47FBC1E2; + ans = 64'h00290090DC021F0B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3338931\n"); + end + x = 64'hBFC494FAB48A29ED; + y = 64'h3800000200000FFE; + z = 64'h9FAFEBFFFFFFFFFF; + ans = 64'hB7D494FD47299511; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3339545\n"); + end + x = 64'h7FDBFFFFFBFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h8000000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3340159\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h434FFFC008000000; + z = 64'hFFEFFFFFFFF8001F; + ans = 64'hFFEFFFFFFFF8001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3340773\n"); + end + x = 64'h418FFDFF80000000; + y = 64'hC340000000000000; + z = 64'hC02FFFFFFFFF003F; + ans = 64'hC4DFFDFF80000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3341387\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h43E0040000000000; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3342001\n"); + end + x = 64'h00200005FFFFFFFE; + y = 64'h950FFFFF7FFFFFF0; + z = 64'hB8039E96058D8A71; + ans = 64'hB8039E96058D8A71; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3342615\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3343229\n"); + end + x = 64'hC34FFC00000FFFFF; + y = 64'h41C7FFFFFFFFFFFE; + z = 64'h3FD0000000000001; + ans = 64'hC527FD00000BFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3343843\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h41D041FFFFFFFFFE; + ans = 64'h41D041FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3344457\n"); + end + x = 64'hC030000000001FFE; + y = 64'hB8178767331561B7; + z = 64'h3DA0080000000080; + ans = 64'h3DA0080000000080; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3345071\n"); + end + x = 64'hD1F00007FE000000; + y = 64'hFFE0000000000001; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3345685\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h37FFFFFFFFFFFD7F; + z = 64'h3F3FFF800000007E; + ans = 64'h3F3FFF800000007E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3346299\n"); + end + x = 64'h000FFFEFDFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h4014569BF0D38E3F; + ans = 64'h3FF15AB0434E3904; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3346913\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hC7F00E76DCEA4AE9; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3347527\n"); + end + x = 64'h3FCFFFFFFFEFFFF6; + y = 64'h4050008000000010; + z = 64'hC1FFEFFFEFFFFFFE; + ans = 64'hC1FFEFFFEEFFF7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3348141\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hFFF0000000000001; + z = 64'h4010000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3348755\n"); + end + x = 64'h4003FFFFFFFFFFFC; + y = 64'h3B9FFFFFFFFFFF87; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CB00013FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3349369\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hBF51FFFFC0000000; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3349983\n"); + end + x = 64'h42007FFFFFFFFFFE; + y = 64'hC05FFFFFFFDFE000; + z = 64'h7FF010000000000E; + ans = 64'h7FF810000000000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3350597\n"); + end + x = 64'h3FD0000000BFFFFE; + y = 64'h0000000000000000; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3351211\n"); + end + x = 64'h8010000000000000; + y = 64'hC03FFFFBFFFFF800; + z = 64'h3EEFFFFFFFFFFFDD; + ans = 64'h3EEFFFFFFFFFFFDD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3351825\n"); + end + x = 64'hC7EFFFFFFFFFFDFF; + y = 64'h0000000000000001; + z = 64'hBF6FFFFF03FFFFFE; + ans = 64'hBF6FFFFF03FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3352439\n"); + end + x = 64'h8010000000000000; + y = 64'hBD4FFFFFFFFFF7FF; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3353053\n"); + end + x = 64'h47F0000000082000; + y = 64'h37FF5000285F803E; + z = 64'h3FEFFE0000000100; + ans = 64'h4007A7801437B3AF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3353667\n"); + end + x = 64'h8010000000000000; + y = 64'h0010000000000000; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3354281\n"); + end + x = 64'h3810000000800003; + y = 64'h3041E7047E3F25CD; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h2861E7047ECE5DF4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3354895\n"); + end + x = 64'h8010000000000000; y = 64'h0010000000000001; - z = 64'h425DE476106384F2; - ans = 64'h425DE476106384F2; + z = 64'h47F9FFFFFFFFFFFE; + ans = 64'h47F9FFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -86376,12 +256892,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3699717\n"); + $fwrite(fp,"3355509\n"); end - x = 64'hABBE8F16F3FE1C83; - y = 64'hC17000007FF80000; - z = 64'h404AE1CA4CBB15D7; - ans = 64'h404AE1CA4CBB15D7; + x = 64'hE59F8003FFFFFFFF; + y = 64'hBFD02EA216C7C36A; + z = 64'h41CFFFFFFF7FEFFF; + ans = 64'h657FDBD32881CE6A; rn = 1; rz = 0; rm = 0; @@ -86423,7 +256939,26891 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3701731\n"); + $fwrite(fp,"3356123\n"); + end + x = 64'hD2F03FFFFBFFFFFE; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3356737\n"); + end + x = 64'h8010000000000000; + y = 64'h402382A8B2E80B9B; + z = 64'hBFB0010004000000; + ans = 64'hBFB0010004000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3357351\n"); + end + x = 64'h403FF7FFFFFFFFFB; + y = 64'h3CA0000000000000; + z = 64'h001FBFFFFFFFFDFF; + ans = 64'h3CEFF7FFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3357965\n"); + end + x = 64'h8010000000000000; + y = 64'h400FFFFFFFC00400; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3358579\n"); + end + x = 64'hBCA00000003FFFFE; + y = 64'h7FD79FFD9502BA89; + z = 64'hFFE03FF000000000; + ans = 64'hFFE03FF000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3359193\n"); + end + x = 64'h8010000000000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3359807\n"); + end + x = 64'h3E400020FFFFFFFE; + y = 64'hC10F7FFBFFFFFFFF; + z = 64'h0010000000000000; + ans = 64'hBF5F803CF7F7BFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3360421\n"); + end + x = 64'h8010000000000000; + y = 64'h3FD0000000000000; + z = 64'hB81FFFFFFFFF80FE; + ans = 64'hB81FFFFFFFFF80FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3361035\n"); + end + x = 64'h3FDFFFDFFFF7FFFE; + y = 64'h3FF000010FFFFFFE; + z = 64'h401FFFBFFFFFF000; + ans = 64'h4020FFDF10FFA700; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3361649\n"); + end + x = 64'h3F0FFFBFFFFDFFFE; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3362263\n"); + end + x = 64'h8010000000000000; + y = 64'hC00FFFFFF8001FFF; + z = 64'hC7F00000FFFDFFFE; + ans = 64'hC7F00000FFFDFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3362877\n"); + end + x = 64'hBFA0003FFFFFF000; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hC049FFFFFFFFFFFF; + ans = 64'hC04A020007FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3363491\n"); + end + x = 64'h8010000000000000; + y = 64'h800FFFDFFFFFDFFF; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3364105\n"); + end + x = 64'hBFDF800000007FFF; + y = 64'h380B8EDE6D7386ED; + z = 64'hAAF0001FFFFFF000; + ans = 64'hB7FB20A2F3BE270C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3364719\n"); + end + x = 64'h8010000000000000; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3FF0000000000000; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3365333\n"); + end + x = 64'h41EF000000007FFF; + y = 64'hBE6FFF7FFFFF7FFF; + z = 64'h0000000000000001; + ans = 64'hC06EFF84000003FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3365947\n"); + end + x = 64'h8010000000000000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h4060000000100007; + ans = 64'h4060000000100007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3366561\n"); + end + x = 64'hBFDFFC90D6E1FC1F; + y = 64'h3CA1FFFFFFFFEFFE; + z = 64'hBFE66AD464A87AAC; + ans = 64'hBFE66AD464A87AAD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3367175\n"); + end + x = 64'h43E00007FFEFFFFE; + y = 64'h3FF0000000000001; + z = 64'h4010000000000001; + ans = 64'h43E00007FFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3367789\n"); + end + x = 64'h8010000000000000; + y = 64'h522FFFFFFBFBFFFF; + z = 64'h7FFFFFFFFFFBFFF7; + ans = 64'h7FFFFFFFFFFBFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3368403\n"); + end + x = 64'h37EFFFFFDFFFFF7F; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC02F5071BEF1B839; + ans = 64'hC02F5071BEF1B839; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3369017\n"); + end + x = 64'h8010000000000000; + y = 64'hFFEFFFFF77FFFFFE; + z = 64'hBFD0000000000001; + ans = 64'h400DFFFF77FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3369631\n"); + end + x = 64'hC7F7EBA22F2EA5FF; + y = 64'h40DFFFFF80000002; + z = 64'h4061000010000000; + ans = 64'hC8E7EBA1CF801D44; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3370245\n"); + end + x = 64'h8010000000000000; + y = 64'h4000000000000001; + z = 64'h3FE0000000000001; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3370859\n"); + end + x = 64'hBFE8329734DA71DB; + y = 64'hC7EFFF7FFFFFFFFA; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3371473\n"); + end + x = 64'h8010000000000000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h40D0000000013FFF; + ans = 64'h40D0000000013FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3372087\n"); + end + x = 64'hB7E4BBDEDAC95C09; + y = 64'hF080000000000016; + z = 64'hB7EFFFFFF8000003; + ans = 64'h6874BBDEDAC95C26; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3372701\n"); + end + x = 64'hCC9FFFFFFF840000; + y = 64'h4010000000000000; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'hCCBFFFFFFF840000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3373315\n"); + end + x = 64'h8010000000000000; + y = 64'h57ADB1B7BA5F902C; + z = 64'h4340800000FFFFFE; + ans = 64'h4340800000FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3373929\n"); + end + x = 64'hBAB0000100000400; + y = 64'h4010000000000001; + z = 64'hBFBFFF8003FFFFFF; + ans = 64'hBFBFFF8003FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3374543\n"); + end + x = 64'h8010000000000000; + y = 64'h7FE00000007FFFC0; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC0000000007FFFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3375157\n"); + end + x = 64'h47E14BC9A7ABAD71; + y = 64'h7FD29E75366A36B5; + z = 64'hEB3FFFFE00000FFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3375771\n"); + end + x = 64'h8010000000000000; + y = 64'h4340000000000000; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3376385\n"); + end + x = 64'hC1F0000000020020; + y = 64'hC0E00080007FFFFE; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3376999\n"); + end + x = 64'h8010000000000000; + y = 64'h4340000000000001; + z = 64'hC7F400FFFFFFFFFE; + ans = 64'hC7F400FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3377613\n"); + end + x = 64'hC1C69CCD52EC0983; + y = 64'hD3E00000000FEFFF; + z = 64'h0910002000004000; + ans = 64'h55B69CCD53028FB2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3378227\n"); + end + x = 64'hFFDA2BDB043076F0; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3378841\n"); + end + x = 64'h8010000000000000; + y = 64'h40707FFFFBFFFFFF; + z = 64'h41CFFFC00003FFFF; + ans = 64'h41CFFFC00003FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3379455\n"); + end + x = 64'hC16A265035CB0A3D; + y = 64'h7FE0000000000000; + z = 64'hBFEFFDFFFF000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3380069\n"); + end + x = 64'h8010000000000000; + y = 64'h3FF0000FFFFFFFFD; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h80280007FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3380683\n"); + end + x = 64'h434000FFFFFFE000; + y = 64'hA167850B540C93BE; + z = 64'h4020100007FFFFFE; + ans = 64'h4020100007FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3381297\n"); + end + x = 64'h8010000000000000; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3381911\n"); + end + x = 64'h47EE080000000000; + y = 64'h3EDFFFF83FFFFFFE; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3382525\n"); + end + x = 64'h8010000000000000; + y = 64'h7FF0000000000000; + z = 64'hB81B02DA624F85A3; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3383139\n"); + end + x = 64'h8000000000000201; + y = 64'hA6D1000000000040; + z = 64'h3E4FFF7DFFFFFFFF; + ans = 64'h3E4FFF7DFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3383753\n"); + end + x = 64'h40D3FFFFFF7FFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h3FF0000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3384367\n"); + end + x = 64'h8010000000000000; + y = 64'h401825A58D846616; + z = 64'hBFF0FFFBFFFFFFFF; + ans = 64'hBFF0FFFBFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3384981\n"); + end + x = 64'h801100000001FFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3A2401EDCE8EAE88; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3385595\n"); + end + x = 64'h8010000000000000; + y = 64'h4FE000000000077F; + z = 64'h8010000000000000; + ans = 64'h900000000000077F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3386209\n"); + end + x = 64'h402000001000007F; + y = 64'hC3D0000010003FFF; + z = 64'h434FFFFFBFFFF7FE; + ans = 64'hC3FFFC004008811D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3386823\n"); + end + x = 64'h8010000000000000; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h3CA0000000000000; + ans = 64'h3CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3387437\n"); + end + x = 64'h405FF80000000FFF; + y = 64'h55200000FFBFFFFF; + z = 64'hC340000000000001; + ans = 64'h558FF801FF002FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3388051\n"); + end + x = 64'h8010000000000000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h41E953F84305CBE0; + ans = 64'h41E953F84305CBE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3388665\n"); + end + x = 64'h9C10100000001FFF; + y = 64'h3CA000000000FC00; + z = 64'hC1E0B989A320F196; + ans = 64'hC1E0B989A320F196; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3389279\n"); + end + x = 64'h38132ABE4909F276; + y = 64'h8010000000000001; + z = 64'h3FE0000000000001; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3389893\n"); + end + x = 64'h8010000000000000; + y = 64'h30EFFFFFF01FFFFF; + z = 64'h3FC232FDBD2A9184; + ans = 64'h3FC232FDBD2A9184; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3390507\n"); + end + x = 64'hF3FFFFFF00007FFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h41E0040000007FFE; + ans = 64'h41E0040000007FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3391121\n"); + end + x = 64'h8010000000000000; + y = 64'hFFF0000000008004; + z = 64'h8000000000000001; + ans = 64'hFFF8000000008004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3391735\n"); + end + x = 64'h24107FFFFFFFFFFE; + y = 64'hC0100400000000FE; + z = 64'h401DD6230D9BE81D; + ans = 64'h401DD6230D9BE81D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3392349\n"); + end + x = 64'h8010000000000000; + y = 64'hBCA0000000000001; + z = 64'h0010000000000001; + ans = 64'h0010000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3392963\n"); + end + x = 64'h37EFFFFFFF8001FF; + y = 64'h40EFFFD7FFFFFFFF; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3393577\n"); + end + x = 64'h8010000000000000; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3FEFF7FFBFFFFFFF; + ans = 64'h3FEFF7FFBFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3394191\n"); + end + x = 64'h41BFFF7FFFFFFBFE; + y = 64'hC0291CCC009FE8EF; + z = 64'h7FFFFFFFC000000E; + ans = 64'h7FFFFFFFC000000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3394805\n"); + end + x = 64'hC0120003FFFFFFFF; + y = 64'hBFD0000000000000; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FFA0003FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3395419\n"); + end + x = 64'h8010000000000000; + y = 64'h80100000FFFFFDFF; + z = 64'h6DC07FFFFFFFBFFF; + ans = 64'h6DC07FFFFFFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3396033\n"); + end + x = 64'h3AB6A4F1D7C0B087; + y = 64'hBFD0000000000001; + z = 64'h3FF00000800000FF; + ans = 64'h3FF00000800000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3396647\n"); + end + x = 64'h8010000000000000; + y = 64'hBF7D582DBB88D647; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3397261\n"); + end + x = 64'hC3E0000002400000; + y = 64'h00100003FFFFFFFB; + z = 64'h43E08000000000FF; + ans = 64'h43E08000000000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3397875\n"); + end + x = 64'h8010000000000000; + y = 64'hBFE0000000000000; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h0017FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3398489\n"); + end + x = 64'h43FA9DBB168CCA00; + y = 64'h417000000000F800; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'h457A9DBB168E668D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3399103\n"); + end + x = 64'h8010000000000000; + y = 64'hBFE0000000000001; + z = 64'hBE027E2F4F0BA6BA; + ans = 64'hBE027E2F4F0BA6BA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3399717\n"); + end + x = 64'h381FFFFFFE0FFFFE; + y = 64'hBF4FFFC002000000; + z = 64'h3CADFFFFFFFDFFFF; + ans = 64'h3CADFFFFFFFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3400331\n"); + end + x = 64'hC04000201FFFFFFE; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h404000201FFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3400945\n"); + end + x = 64'h8010000000000000; + y = 64'hBCAFFFFF7FFFEFFE; + z = 64'hC1FFFFF8007FFFFF; + ans = 64'hC1FFFFF8007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3401559\n"); + end + x = 64'hBF1FC01FFFFFFFFE; + y = 64'hBFF0000000000000; + z = 64'hC3C02000000003FE; + ans = 64'hC3C02000000003FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3402173\n"); + end + x = 64'h8010000000000000; + y = 64'h43FD5D2E92764475; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3402787\n"); + end + x = 64'hBE0ED055692EBF18; + y = 64'hFFFFFFFFFFFF03FE; + z = 64'h37EA1A5EB2077F40; + ans = 64'hFFFFFFFFFFFF03FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3403401\n"); + end + x = 64'h8010000000000000; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3404015\n"); + end + x = 64'h7FF0010000000007; + y = 64'h400FFFFFE0000004; + z = 64'hC000000000000000; + ans = 64'h7FF8010000000007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3404629\n"); + end + x = 64'h8010000000000000; + y = 64'hC000000000000000; + z = 64'h400FFFFFFF7FFFFE; + ans = 64'h400FFFFFFF7FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3405243\n"); + end + x = 64'hBF34EA21CDC8CADA; + y = 64'hC0800200000FFFFF; + z = 64'h401FFFFFFEEFFFFF; + ans = 64'h402053B2FBC05DB8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3405857\n"); + end + x = 64'hC9EFFFF800003FFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h3CA0000000000000; + ans = 64'h4A0FFFF800003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3406471\n"); + end + x = 64'h8010000000000000; + y = 64'h7FFFFFFFFFDFFFFF; + z = 64'h480FFFFFFFEFFC00; + ans = 64'h7FFFFFFFFFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3407085\n"); + end + x = 64'hC81F7FFFFFFFFEFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBF9AE67AFF0983D8; + ans = 64'h483F7FFFFFFFFEFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3407699\n"); + end + x = 64'h8010000000000000; + y = 64'h43C3AED15D7EED2D; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3408313\n"); + end + x = 64'h47F00000FFFFBFFF; + y = 64'h006FF7FFFFFFFFFB; + z = 64'h7FEFF7FF80000000; + ans = 64'h7FEFF7FF80000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3408927\n"); + end + x = 64'h8010000000000000; + y = 64'hC010000000000001; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3409541\n"); + end + x = 64'h37F0000003FFFFF7; + y = 64'hBF23FFFF7FFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3410155\n"); + end + x = 64'h8010000000000000; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h43C8E9C48CCC5395; + ans = 64'h43C8E9C48CCC5395; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3410769\n"); + end + x = 64'h3F50F7FFFFFFFFFF; + y = 64'hC1E0000017FFFFFF; + z = 64'hBFAE4E3B838772A5; + ans = 64'hC140F80021078EDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3411383\n"); + end + x = 64'h3FFFFF07FFFFFFFF; + y = 64'hC340000000000001; + z = 64'h0010000000000001; + ans = 64'hC34FFF0800000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3411997\n"); + end + x = 64'h8010000000000000; + y = 64'hBFC1000000000002; + z = 64'h37E6F76741D61EDF; + ans = 64'h37E6F76741D61EDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3412611\n"); + end + x = 64'h3ED7BBC3B97CC198; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC7F1001FFFFFFFFF; + ans = 64'hC7F1001FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3413225\n"); + end + x = 64'h8010000000000000; + y = 64'hC1FFFFF7FFEFFFFF; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3413839\n"); + end + x = 64'hBFF0000000880000; + y = 64'h43DFE00000020000; + z = 64'h3C9000000FBFFFFF; + ans = 64'hC3DFE0000110F000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3414453\n"); + end + x = 64'h8010000000000000; + y = 64'hFFE0000000000000; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3415067\n"); + end + x = 64'h455004000000003E; + y = 64'hC3C38570142B9A35; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hC9238A517030A567; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3415681\n"); + end + x = 64'h8010000000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hB7FEFFF7FFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3416295\n"); + end + x = 64'h41CE002000000000; + y = 64'h47E74F59B8787E2A; + z = 64'h404A24AB53AA6DE2; + ans = 64'h49C5DA7B6C4AAEC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3416909\n"); + end + x = 64'h40319890A0A917DD; + y = 64'hFFF0000000000000; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3417523\n"); + end + x = 64'h8010000000000000; + y = 64'hC0380007FFFFFFFF; + z = 64'hBCAFFFFFFFFEFC00; + ans = 64'hBCAFFFFFFFFEFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3418137\n"); + end + x = 64'h43E0000FFFFFBFFE; + y = 64'hFFF0000000000001; + z = 64'hC1EFFBF7FFFFFFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3418751\n"); + end + x = 64'h8010000000000000; + y = 64'h47EC85E3B2608045; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3419365\n"); + end + x = 64'h4462750B8EBD954D; + y = 64'h40366C327960A626; + z = 64'h457FC0FFFFFFFFFF; + ans = 64'h457FC1CEEE016087; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3419979\n"); + end + x = 64'h8010000000000000; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3420593\n"); + end + x = 64'h8C16F70C4AD7B5FF; + y = 64'hC0659F877D27364D; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3421207\n"); + end + x = 64'h8010000000000001; + y = 64'h0000000000000001; + z = 64'h40400000001FFFFF; + ans = 64'h40400000001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3421821\n"); + end + x = 64'h3FFFFE7FFFFFFFFF; + y = 64'hFFF07FBFFFFFFFFE; + z = 64'h37EEAC45D6E6F956; + ans = 64'hFFF87FBFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3422435\n"); + end + x = 64'hC090000800000008; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3423049\n"); + end + x = 64'h8010000000000001; + y = 64'h4030000080000400; + z = 64'h3814DAE88176666D; + ans = 64'h3814DAE88176666D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3423663\n"); + end + x = 64'hC3F00000FFF80000; + y = 64'h0010000000000000; + z = 64'h58200000000FFF00; + ans = 64'h58200000000FFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3424277\n"); + end + x = 64'h8010000000000001; + y = 64'hBE5FFFFFFFF9FFFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3424891\n"); + end + x = 64'h7FD0FFFC00000000; + y = 64'h245FFFFFFFFFFFF6; + z = 64'h001E996DE223F216; + ans = 64'h6440FFFBFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3425505\n"); + end + x = 64'h8010000000000001; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3426119\n"); + end + x = 64'h327FFFFFFFFF0FFF; + y = 64'h002FFFFFF000007E; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3426733\n"); + end + x = 64'h8010000000000001; + y = 64'h3CA0000000000000; + z = 64'hBFEBFFFFFFF7FFFE; + ans = 64'hBFEBFFFFFFF7FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3427347\n"); + end + x = 64'h3D4AF0C44F073F7C; + y = 64'hB7EFFEFFFFFF7FFE; + z = 64'hC29271AA05B991D9; + ans = 64'hC29271AA05B991D9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3427961\n"); + end + x = 64'h0016FB8958D5CE7A; + y = 64'h3CA0000000000001; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3428575\n"); + end + x = 64'h8010000000000001; + y = 64'h40100200000007FE; + z = 64'hBE200000000C0000; + ans = 64'hBE200000000C0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3429189\n"); + end + x = 64'h417FFFFFFFFE00FF; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hC3D0800200000000; + ans = 64'hC3D0800200000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3429803\n"); + end + x = 64'h8010000000000001; + y = 64'h4EB4F75D91518E6B; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3430417\n"); + end + x = 64'h381FFFFFE3FFFFFE; + y = 64'hBFE0000000017FFF; + z = 64'h3FB9479D54939987; + ans = 64'h3FB9479D54939987; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3431031\n"); + end + x = 64'h8010000000000001; + y = 64'h3FD0000000000001; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3431645\n"); + end + x = 64'hC0000000003FFFFF; + y = 64'h3FEFFFFFFF801FFF; + z = 64'hBCA0000000000001; + ans = 64'hC000000000000FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3432259\n"); + end + x = 64'h8010000000000001; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hB8F0000003FFFFBE; + ans = 64'hB8F0000003FFFFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3432873\n"); + end + x = 64'h47CFF7FFFFFFFFFF; + y = 64'h000403FFFFFFFFFF; + z = 64'h4010000010000006; + ans = 64'h4010000010000006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3433487\n"); + end + x = 64'h3E1F7FFFFFFDFFFE; + y = 64'h3FE0000000000000; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3434101\n"); + end + x = 64'h8010000000000001; + y = 64'hC02FFFFFFFFFFBFE; + z = 64'hC3CFFFFFFFFFFFEB; + ans = 64'hC3CFFFFFFFFFFFEB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3434715\n"); + end + x = 64'h403FFFFFFBFFFBFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h41FFFFFF80000040; + ans = 64'h41FFFFFF82000040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3435329\n"); + end + x = 64'h8010000000000001; + y = 64'hBFCFFFFFFFFEFFF8; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3435943\n"); + end + x = 64'hBFE000800000000E; + y = 64'hBF203FFFFFBFFFFE; + z = 64'hBFBDA817ACC5E05E; + ans = 64'hBFBDA4078C45F05E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3436557\n"); + end + x = 64'h8010000000000001; + y = 64'h3FF0000000000000; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3437171\n"); + end + x = 64'h7FE800000000003E; + y = 64'h8004DE935D68D1E8; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'hBFED37743074EBBB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3437785\n"); + end + x = 64'h8010000000000001; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC800000000007FEF; + ans = 64'hC800000000007FEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3438399\n"); + end + x = 64'hCD0A506F0E26FC02; + y = 64'hBFADFFFFFFFFC000; + z = 64'hC5200003FFFBFFFF; + ans = 64'h4CC8AB681D4457A1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3439013\n"); + end + x = 64'hBAB03FFFFFFE0000; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3439627\n"); + end + x = 64'h8010000000000001; + y = 64'h26DFFFBFFF800000; + z = 64'h40D81EF424CFD2A4; + ans = 64'h40D81EF424CFD2A4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3440241\n"); + end + x = 64'hBFC6CE5CC791295B; + y = 64'h4000000000000001; + z = 64'h4800000010000008; + ans = 64'h4800000010000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3440855\n"); + end + x = 64'h8010000000000001; + y = 64'hD6C0001FFFFFFFFE; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3441469\n"); + end + x = 64'h0FD00005FFFFFFFF; + y = 64'h38002000000001FF; + z = 64'h403FFFFFFFFFFF7F; + ans = 64'h403FFFFFFFFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3442083\n"); + end + x = 64'h8010000000000001; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3442697\n"); + end + x = 64'hBF3FFF8003FFFFFF; + y = 64'h3F9005FFFFFFFFFE; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hBEE005BFEA00BFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3443311\n"); + end + x = 64'h8010000000000001; + y = 64'h4010000000000001; + z = 64'hC3DFFFFFFF8FFFFF; + ans = 64'hC3DFFFFFFF8FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3443925\n"); + end + x = 64'hC1C0000800000010; + y = 64'hC801FFFFF0000000; + z = 64'h6B00000100000000; + ans = 64'h6B00000100000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3444539\n"); + end + x = 64'hC7F22D8469F0C3B1; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC8222D8469F0C3B0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3445153\n"); + end + x = 64'h8010000000000001; + y = 64'h3FEFFDFFEFFFFFFF; + z = 64'hBF8007FFFF800000; + ans = 64'hBF8007FFFF800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3445767\n"); + end + x = 64'h4190000000000060; + y = 64'h4340000000000000; + z = 64'hBFD81177F4F07753; + ans = 64'h44E0000000000060; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3446381\n"); + end + x = 64'h8010000000000001; + y = 64'hB7EFDDFFFFFFFFFF; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3446995\n"); + end + x = 64'hC8000001F7FFFFFF; + y = 64'hB7FE00000003FFFF; + z = 64'hBFB0000FFFFFFFFE; + ans = 64'h400D80033103FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3447609\n"); + end + x = 64'h8010000000000001; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3448223\n"); + end + x = 64'h43DFFC00000FFFFE; + y = 64'h3E6F7FFFFF7FFFFE; + z = 64'h8000000000000000; + ans = 64'h425F7C0FFF8FCFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3448837\n"); + end + x = 64'h8010000000000001; + y = 64'h7FE0000000000000; + z = 64'hBF101FFFFFF7FFFF; + ans = 64'hC00000203FFFFFF1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3449451\n"); + end + x = 64'hAA50008000000000; + y = 64'hB7EFFFFF001FFFFE; + z = 64'hBFFFFFFFFFEFFE00; + ans = 64'hBFFFFFFFFFEFFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3450065\n"); + end + x = 64'h37FBFFFFFFEFFFFF; + y = 64'h7FE0000000000001; + z = 64'hC010000000000000; + ans = 64'h77EBFFFFFFF00001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3450679\n"); + end + x = 64'h8010000000000001; + y = 64'h800F7FFFFFFFFF80; + z = 64'h37B00000083FFFFF; + ans = 64'h37B00000083FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3451293\n"); + end + x = 64'h402FFFC07FFFFFFE; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h400FBBFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3451907\n"); + end + x = 64'h8010000000000001; + y = 64'hC0FFFFFFFFF01FFE; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3452521\n"); + end + x = 64'h000000000000007A; + y = 64'hC34B191A46C9F624; + z = 64'h41FFFFFFFFFDBFFE; + ans = 64'h41FFFFFFFFFDBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3453135\n"); + end + x = 64'h8010000000000001; + y = 64'h7FF0000000000001; + z = 64'hBFE0000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3453749\n"); + end + x = 64'hBFFFFFBFFFFFBFFF; + y = 64'hCF7FF000003FFFFF; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3454363\n"); + end + x = 64'h8010000000000001; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3FF2C214BD28AB14; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3454977\n"); + end + x = 64'hC3400007FFFFFBFF; + y = 64'h3E10000000200400; + z = 64'hBFA0010010000000; + ans = 64'hC160000801201010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3455591\n"); + end + x = 64'hC3CFEFFFFFEFFFFE; + y = 64'h8000000000000000; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3456205\n"); + end + x = 64'h8010000000000001; + y = 64'h402FFFF800000000; + z = 64'hBFFFFC01FFFFFFFE; + ans = 64'hBFFFFC01FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3456819\n"); + end + x = 64'h41D00000F7FFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h41900000001BFFFE; + ans = 64'h41900000001BFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3457433\n"); + end + x = 64'h8010000000000001; + y = 64'hBE6FFE000000FFFF; + z = 64'h3CA0000000000001; + ans = 64'h3CA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3458047\n"); + end + x = 64'h47E2000FFFFFFFFF; + y = 64'h5EEB8AC00B21E1F9; + z = 64'h8000000003FFFFFE; + ans = 64'h66DEFC3397462958; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3458661\n"); + end + x = 64'h8010000000000001; + y = 64'h8010000000000000; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3459275\n"); + end + x = 64'h401F5D0E48FDF300; + y = 64'hC27FFFFDFFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3459889\n"); + end + x = 64'h8010000000000001; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h402403B9376E4ABD; + ans = 64'h402403B9376E4ABD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3460503\n"); + end + x = 64'hC7E0000000000102; + y = 64'h32CFFFFFFFFC07FF; + z = 64'h04CFFF7FFFFFFDFE; + ans = 64'hBABFFFFFFFFC0A03; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3461117\n"); + end + x = 64'h41F911036CBF63B6; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3461731\n"); + end + x = 64'h8010000000000001; + y = 64'h2AAAFFFFFFFFFFFF; + z = 64'hDF0FDD09B53983F3; + ans = 64'hDF0FDD09B53983F3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3462345\n"); + end + x = 64'hBEF001001FFFFFFF; + y = 64'hBCA0000000000001; + z = 64'hBDE07FFFFFFFFC00; + ans = 64'hBDE07FFFFFFEFBF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3462959\n"); + end + x = 64'h8010000000000001; + y = 64'hC060000FFFFFFFF6; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h0080400FFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3463573\n"); + end + x = 64'hC3C01FFFFFEFFFFF; + y = 64'h40200000001FFFFD; + z = 64'h43F003FFFFFBFFFE; + ans = 64'hC37C0000143FFDFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3464187\n"); + end + x = 64'h8010000000000001; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3464801\n"); + end + x = 64'hBE656A583A6372FE; + y = 64'hB81FFFFFFFC20000; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3465415\n"); + end + x = 64'h8010000000000001; + y = 64'hBFD0000000000001; + z = 64'h3EF00101FFFFFFFF; + ans = 64'h3EF00101FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3466029\n"); + end + x = 64'hC05D5279C4F75DDD; + y = 64'h410FBFFEFFFFFFFF; + z = 64'hBD90FF8000000000; + ans = 64'hC17D17D3E6D9A0F9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3466643\n"); + end + x = 64'hC01FF0000FFFFFFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h4007F0000FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3467257\n"); + end + x = 64'h8010000000000001; + y = 64'hC7FFBFFFFFFFFFF8; + z = 64'h3F7FFFFFFFFFFFFF; + ans = 64'h3F7FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3467871\n"); + end + x = 64'h3FD0000001C00000; + y = 64'hBFE0000000000000; + z = 64'hBA900000FFFFFFFF; + ans = 64'hBFC0000001C00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3468485\n"); + end + x = 64'h8010000000000001; + y = 64'h434C50942BB01F08; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h836C50942BB01F09; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3469099\n"); + end + x = 64'hBFB000000807FFFF; + y = 64'h47EFF7FE00000000; + z = 64'hB7E07FFFFFFFBFFF; + ans = 64'hC7AFF7FE100BFAFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3469713\n"); + end + x = 64'h8010000000000001; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h800FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3470327\n"); + end + x = 64'h3FF001FFDFFFFFFE; + y = 64'h402EFFFFFFFFFC00; + z = 64'h4340000000000000; + ans = 64'h4340000000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3470941\n"); + end + x = 64'h8010000000000001; + y = 64'hBFF0000000000000; + z = 64'hB6E0000002200000; + ans = 64'hB6E0000002200000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3471555\n"); + end + x = 64'hC1FF800001FFFFFE; + y = 64'h4400000001FFFFF8; + z = 64'hB81F8000000003FF; + ans = 64'hC60F800005EFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3472169\n"); + end + x = 64'hAE5F801FFFFFFFFF; + y = 64'hBFF0000000000001; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3472783\n"); + end + x = 64'h8010000000000001; + y = 64'h7FD00000000103FE; + z = 64'h3F900003FFFFDFFF; + ans = 64'hBFEF7FFFE00208FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3473397\n"); + end + x = 64'h253FFFFE01FFFFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBFDF800007FFFFFF; + ans = 64'hBFDF800007FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3474011\n"); + end + x = 64'h8010000000000001; + y = 64'hC097F535A94B8768; + z = 64'h0000000000000000; + ans = 64'h00B7F535A94B8769; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3474625\n"); + end + x = 64'hBFCFFFFFFF03FFFF; + y = 64'h7FFC04AA4A34A9A1; + z = 64'hB7E8A2BA0464A248; + ans = 64'h7FFC04AA4A34A9A1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3475239\n"); + end + x = 64'h8010000000000001; + y = 64'hC000000000000001; + z = 64'h8010000000000000; + ans = 64'h0010000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3475853\n"); + end + x = 64'h3FDFFEFFFFFFC000; + y = 64'hC1FFDFFFF8000000; + z = 64'h4010000000000001; + ans = 64'hC1EFDF00F7800040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3476467\n"); + end + x = 64'h8010000000000001; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h2162E1C38925382F; + ans = 64'h2162E1C38925382F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3477081\n"); + end + x = 64'h41EFF7FFFEFFFFFE; + y = 64'hC00FFF7FFFFFFFFF; + z = 64'h4C40000007F7FFFE; + ans = 64'h4C40000007F7FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3477695\n"); + end + x = 64'hC420000FFDFFFFFF; + y = 64'hC010000000000000; + z = 64'hBFD0000000000001; + ans = 64'h4440000FFDFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3478309\n"); + end + x = 64'h8010000000000001; + y = 64'h37EFFFFFFFFFEEFE; + z = 64'h802FFFFFFFFFFDFE; + ans = 64'h802FFFFFFFFFFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3478923\n"); + end + x = 64'hBB9010000001FFFE; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h400FFFF80000003E; + ans = 64'h400FFFF80000003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3479537\n"); + end + x = 64'h8010000000000001; + y = 64'hC26FFFFFFFBFFF80; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3480151\n"); + end + x = 64'h3FBFFFFFFFFFF7FD; + y = 64'hB7FA36D046DE74F2; + z = 64'h422FFFFE00200000; + ans = 64'h422FFFFE00200000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3480765\n"); + end + x = 64'h8010000000000001; + y = 64'hC340000000000000; + z = 64'h8000000000000001; + ans = 64'h0360000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3481379\n"); + end + x = 64'h43FFBFFFFEFFFFFF; + y = 64'h1C97F43A22A60B85; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3481993\n"); + end + x = 64'h8010000000000001; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h002175F4C9217C07; + ans = 64'h0370000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3482607\n"); + end + x = 64'hC13FDC0000000000; + y = 64'hC6E98960D74C89F6; + z = 64'h26F007FEFFFFFFFF; + ans = 64'h48396CA64A5A53DB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3483221\n"); + end + x = 64'h380FFC000003FFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCB00000FFE00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3483835\n"); + end + x = 64'h8010000000000001; + y = 64'h41EB3544B5D48790; + z = 64'h43CFFFFFF7FFFEFF; + ans = 64'h43CFFFFFF7FFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3484449\n"); + end + x = 64'hC03000080000003F; + y = 64'hFFE0000000000001; + z = 64'h402007FFFDFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3485063\n"); + end + x = 64'h8010000000000001; + y = 64'hBF2F7FFFFFFBFFFF; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3485677\n"); + end + x = 64'hC1EFFFFC07FFFFFF; + y = 64'h4EF8FD99B216C7A4; + z = 64'h47FFFFFFFFFF8010; + ans = 64'hD0F8FD9698A2F7CD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3486291\n"); + end + x = 64'h8010000000000001; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3486905\n"); + end + x = 64'h7FEA9C0EFE0A98BD; + y = 64'h403E000400000000; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3487519\n"); + end + x = 64'h8010000000000001; + y = 64'hFFF0000000000001; + z = 64'hB7E0005FFFFFFFFE; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3488133\n"); + end + x = 64'h372FFFFBFFFFFFFF; + y = 64'h00200003FDFFFFFF; + z = 64'h43474A03BCE98E5F; + ans = 64'h43474A03BCE98E5F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3488747\n"); + end + x = 64'h3C5BE00000000000; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3489361\n"); + end + x = 64'h8010000000000001; + y = 64'hC0B7FFFFFFFFFFF7; + z = 64'h946000000001BFFE; + ans = 64'h946000000001BFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3489975\n"); + end + x = 64'h43F3FFFFFFFFDFFE; + y = 64'h0000000000000000; + z = 64'hF4D00007FFF7FFFF; + ans = 64'hF4D00007FFF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3490589\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC03FE00000FFFFFE; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3491203\n"); + end + x = 64'h3FE506CBB5C9EF4A; + y = 64'hC34F7DFFFFFFFFFF; + z = 64'h380CC9555D83D483; + ans = 64'hC344B1601A376AED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3491817\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3492431\n"); + end + x = 64'hC3DFFFFF80000002; + y = 64'h41C00000002007FF; + z = 64'h3FF0000000000000; + ans = 64'hC5AFFFFF80400FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3493045\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h0010000000000000; + z = 64'hC1EFFFFFF81FFFFE; + ans = 64'hC1EFFFFFF81FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3493659\n"); + end + x = 64'hC00FFFFFE0000003; + y = 64'hC7E0000070000000; + z = 64'hBFFFE000000001FF; + ans = 64'h480000005FFFFF92; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3494273\n"); + end + x = 64'h4C90FFFC00000000; + y = 64'h0010000000000001; + z = 64'h8010000000000000; + ans = 64'h0CB0FFFC00000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3494887\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h434FA2E02353B267; + z = 64'hBD91FFFFFFBFFFFF; + ans = 64'hBD91FFFFFFBFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3495501\n"); + end + x = 64'h800FFFFFFFBFDFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hC09FFFFFE0000003; + ans = 64'hC09FFFFFE0000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3496115\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h413FFFFDFFFFFF7F; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3496729\n"); + end + x = 64'h400FFFFFFE000003; + y = 64'h47E3EFFFFFFFFFFE; + z = 64'hFFD2F1E7ED80838D; + ans = 64'hFFD2F1E7ED80838D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3497343\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3CA0000000000001; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3497957\n"); + end + x = 64'hC2AFFFFFFFFFFFE6; + y = 64'h401FFF8FFFFFFFFF; + z = 64'h3FE0000000000001; + ans = 64'hC2DFFF8FFFFFFFC5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3498571\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3FA0FFFFFFFFFDFF; + ans = 64'h3FA0FFFFFFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3499185\n"); + end + x = 64'hDED45D2D699E6FBD; + y = 64'h3F9FFFE0001FFFFE; + z = 64'h3C0FFFFEFFFFFFF6; + ans = 64'hDE845D190C85634B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3499799\n"); + end + x = 64'h3F9FFFEFFFFFFFFF; + y = 64'h3FD0000000000000; + z = 64'h8000000000000001; + ans = 64'h3F7FFFEFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3500413\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC5D0010FFFFFFFFE; + z = 64'hC1C007FEFFFFFFFF; + ans = 64'hC1C007FEFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3501027\n"); + end + x = 64'hC7EFFFFFFFFFFFAF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h43DFFFF7FFFFFFFD; + ans = 64'hC7DFFFFFFFFFFFAE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3501641\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3FDFFFE000000000; + z = 64'hC010000000000001; + ans = 64'hC010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3502255\n"); + end + x = 64'h43C000001FFF7FFF; + y = 64'hC0AFFFFFF0000040; + z = 64'h3FCAC386871DE4A6; + ans = 64'hC480000017FF800F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3502869\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3FE0000000000000; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3503483\n"); + end + x = 64'h3EC80743205F2B82; + y = 64'h3FDF00000007FFFF; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FE00002E8E120EC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3504097\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3FE0000000000001; + z = 64'hBFCFF3FFFFFFFFFF; + ans = 64'hBFCFF3FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3504711\n"); + end + x = 64'h6D70000007FFFFEF; + y = 64'hC22FFF00003FFFFE; + z = 64'h7FD00FFFFFDFFFFF; + ans = 64'h7FD00FFFFFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3505325\n"); + end + x = 64'h3FA000000400FFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3505939\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3FCF800001FFFFFE; + z = 64'hBCA0000FF8000000; + ans = 64'hBCA0000FF8000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3506553\n"); + end + x = 64'h3970000000200000; + y = 64'h3FF0000000000001; + z = 64'h40700000000100FF; + ans = 64'h40700000000100FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3507167\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC1FFFFFFFFFFCFFE; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3507781\n"); + end + x = 64'hC3FFFFFFFF7FF7FF; + y = 64'h3D5DB9AE86D5D3FA; + z = 64'h43D00000000407FF; + ans = 64'h43D000000003CC8C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3508395\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3509009\n"); + end + x = 64'h381000010000003E; + y = 64'h43FFFF000000003F; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CB007FFC07FFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3509623\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h4000000000000000; + z = 64'h48049FCD56F7E1F9; + ans = 64'h48049FCD56F7E1F9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3510237\n"); + end + x = 64'h0010000400000400; + y = 64'hC80FE00000003FFE; + z = 64'h43D0000000001FFF; + ans = 64'h43D0000000001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3510851\n"); + end + x = 64'h3649AFC65D0A6F1A; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3511465\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h4024A534AC48D6E4; + z = 64'h3E7FFFFFFF7FE000; + ans = 64'h3E7FFFFFFF7FE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3512079\n"); + end + x = 64'hBFEFFFFFFFFF7FDE; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hC7EFFBFFFFFFFFEE; + ans = 64'hC7EFFBFFFFFFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3512693\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h0020C022F6C81829; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3513307\n"); + end + x = 64'hBD5FFFFFC0000040; + y = 64'hFFD0000037FFFFFF; + z = 64'hB7FFFF0000003FFF; + ans = 64'h7D40000017FFFFAF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3513921\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3514535\n"); + end + x = 64'h0020800000000040; + y = 64'h855FFFFC00800000; + z = 64'h3CA0000000000000; + ans = 64'h3CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3515149\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h7FDEF537F9C2304D; + ans = 64'h7FDEF537F9C2304D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3515763\n"); + end + x = 64'h402FFFFFFFBFFDFF; + y = 64'h380E71F983F5560D; + z = 64'h40107FF7FFFFFFFF; + ans = 64'h40107FF7FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3516377\n"); + end + x = 64'h38022398FCD2938A; + y = 64'h4340000000000001; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3516991\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h4063FFFFFF7FFFFF; + z = 64'hC34E00000000001F; + ans = 64'hC34E00000000001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3517605\n"); + end + x = 64'h6900040FFFFFFFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h3CA0000820000000; + ans = 64'h6C60040FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3518219\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hBF40008200000000; + z = 64'hBFF0000000000000; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3518833\n"); + end + x = 64'hE86000003FFFFFF7; + y = 64'hBFCFFFFFFFF003FE; + z = 64'hBF8FFFFEFFDFFFFE; + ans = 64'h684000003FF801F6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3519447\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h7FE0000000000001; + z = 64'h4000000000000000; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3520061\n"); + end + x = 64'h3CA3B66E73907425; + y = 64'hC347B0AB22B11B1E; + z = 64'h0010000000000001; + ans = 64'hBFFD2FE85D912D4F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3520675\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hC1FFFFBBFFFFFFFF; + ans = 64'hC1FFFFBC007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3521289\n"); + end + x = 64'hC7E00000000003EF; + y = 64'hC0DFFFFFFFBFE000; + z = 64'h41EFFFFFFE03FFFF; + ans = 64'h48CFFFFFFFBFE7DE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3521903\n"); + end + x = 64'hD8BEFFFFF7FFFFFF; + y = 64'h7FF0000000000000; + z = 64'h4340000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3522517\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h40300000003FEFFF; + z = 64'h3EC007DFFFFFFFFF; + ans = 64'h3EC007DFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3523131\n"); + end + x = 64'h38DFFFFBFFFFFDFE; + y = 64'h7FF0000000000001; + z = 64'hC3FE5E4374175B59; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3523745\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h403FFFFEFDFFFFFF; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3524359\n"); + end + x = 64'h403FFFFFEFEFFFFE; + y = 64'hBB2000080007FFFE; + z = 64'hBE2C76A7686DFB50; + ans = 64'hBE2C76A7686DFD50; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3524973\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h8000000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3525587\n"); + end + x = 64'h4104000000FFFFFF; + y = 64'hC3C3FFFFFFFFFBFF; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hC4D90000013FFAFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3526201\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h8000000000000001; + z = 64'hC800000000001FFE; + ans = 64'hC800000000001FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3526815\n"); + end + x = 64'hBCA3FFFFFF7FFFFE; + y = 64'h7CFFFFFFFFFFFF86; + z = 64'hC7E0000008007FFF; + ans = 64'hF9B3FFFFFF7FFFB2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3527429\n"); + end + x = 64'h4050000000081FFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3528043\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC27F800000080000; + z = 64'h400FFF000FFFFFFE; + ans = 64'h400FFF000FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3528657\n"); + end + x = 64'h3CA0000400000800; + y = 64'h8010000000000000; + z = 64'h41F0900000000000; + ans = 64'h41F0900000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3529271\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3E57FFFFFFFFF7FE; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3529885\n"); + end + x = 64'hBFFFFFFFFFFFF7FE; + y = 64'hBFD00000021FFFFF; + z = 64'hC1CFFFBEFFFFFFFF; + ans = 64'hC1CFFFBEFFBFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3530499\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3531113\n"); + end + x = 64'h40CFFFFFFE00003F; + y = 64'h3EAFBFFFFFFFFFF0; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3531727\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hBCA0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3532341\n"); + end + x = 64'h40D003FFBFFFFFFF; + y = 64'hC0196164645A61E5; + z = 64'h402B42415A9A50D4; + ans = 64'hC0F966E245E31218; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3532955\n"); + end + x = 64'h41DD5E1041ECA9F1; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFC543DF7A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3533569\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC780000006FFFFFF; + z = 64'h82E3CEE5E282FCA6; + ans = 64'h07B0000006FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3534183\n"); + end + x = 64'h400FFFFF800FFFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h43FFC00000000007; + ans = 64'h43FFC00000000007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3534797\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h403FFFFC00000080; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hBCAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3535411\n"); + end + x = 64'hE53FF80000008000; + y = 64'h40327D016FBE9017; + z = 64'h49194977C779FC34; + ans = 64'hE58278622F62EA67; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3536025\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3536639\n"); + end + x = 64'hC1CFFFE000000001; + y = 64'h43F9C62BF671BF1C; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3537253\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h0000000000021FFF; + ans = 64'h0010000000021FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3537867\n"); + end + x = 64'hC3D080003FFFFFFE; + y = 64'h7FFFFFFFFFFBF7FF; + z = 64'hC0BFF7FFFFFFFFFF; + ans = 64'h7FFFFFFFFFFBF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3538481\n"); + end + x = 64'h402FF00000FFFFFF; + y = 64'hBFE0000000000001; + z = 64'h4000000000000000; + ans = 64'hC017F00001000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3539095\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3E2000000008001E; + z = 64'hC623ABA49F8E6A01; + ans = 64'hC623ABA49F8E6A01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3539709\n"); + end + x = 64'h41D000007FFFFFEF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h385FFF8000FFFFFE; + ans = 64'hC1D000007FFFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3540323\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h43E03FFFFFC00000; + z = 64'hBCA0000000000000; + ans = 64'hBCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3540937\n"); + end + x = 64'hB890000000000203; + y = 64'hBFFBFC0000000000; + z = 64'hDFB98E7EA50A7F54; + ans = 64'hDFB98E7EA50A7F54; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3541551\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hBFF0000000000001; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3542165\n"); + end + x = 64'hB8001FFFFFFFFFDF; + y = 64'h3E03C923713BC58E; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3542779\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hC1D000000080007F; + ans = 64'hC1D000000080007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3543393\n"); + end + x = 64'hBFDAE20492ABEECE; + y = 64'h000FFFFFFFE0001F; + z = 64'hC00C81C068E036FB; + ans = 64'hC00C81C068E036FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3544007\n"); + end + x = 64'hC02E97087858051B; + y = 64'hC000000000000000; + z = 64'h3FF0000000000001; + ans = 64'h403F97087858051B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3544621\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3FEEFFFFFFF7FFFE; + z = 64'h3977FFFFF8000000; + ans = 64'h3977FFFFF8000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3545235\n"); + end + x = 64'h841489E493F1E3FB; + y = 64'hC000000000000001; + z = 64'hB7FFFFFFF1FFFFFF; + ans = 64'hB7FFFFFFF1FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3545849\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hA4780952CC27292A; + z = 64'h8010000000000001; + ans = 64'h8010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3546463\n"); + end + x = 64'h3C60000000FFFFF7; + y = 64'hC000000003FF7FFF; + z = 64'hC0140001FFFFFFFF; + ans = 64'hC0140001FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3547077\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC010000000000000; + z = 64'h3CA0000000000001; + ans = 64'h3CA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3547691\n"); + end + x = 64'hB81FFFBFFBFFFFFF; + y = 64'h41DFFE0001FFFFFF; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC34FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3548305\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC010000000000001; + z = 64'hC1C000080000007F; + ans = 64'hC1C000080000007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3548919\n"); + end + x = 64'h400007FFF0000000; + y = 64'h401FE00000000003; + z = 64'h3FB0000000001080; + ans = 64'h403007F7F0100012; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3549533\n"); + end + x = 64'h3FF3FFFFFFFFFFFD; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'hC021FFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3550147\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC01FFFFFE003FFFF; + z = 64'h3FC08A330A869AF2; + ans = 64'h3FC08A330A869AF2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3550761\n"); + end + x = 64'h41DB6C4ECDBC587A; + y = 64'hC340000000000000; + z = 64'h3FDA48692615FFD5; + ans = 64'hC52B6C4ECDBC587A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3551375\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC5E0000001000000; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h0610000000FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3551989\n"); + end + x = 64'hF1FF80000000000E; + y = 64'hC3C0008000000001; + z = 64'hB6FFFFFBFFFFFFDF; + ans = 64'h75CF80FC00000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3552603\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h037FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3553217\n"); + end + x = 64'h8000002FFFFFFFFF; + y = 64'h56C3FFFEFFFFFFFF; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3553831\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hFFE0000000000000; + z = 64'hFFE52EC42BD5246C; + ans = 64'hFFE52EC42BD5246C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3554445\n"); + end + x = 64'h3AE000A000000000; + y = 64'hBFC9DD9C9FA6F045; + z = 64'hAC4FFFFFF800001E; + ans = 64'hBAB9DE9F47C52CCA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3555059\n"); + end + x = 64'hB8000010000001FF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h78000010000001FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3555673\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC03FFFDFFFEFFFFF; + z = 64'hD8CFEFFFFDFFFFFE; + ans = 64'hD8CFEFFFFDFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3556287\n"); + end + x = 64'h4F1FFEFFEFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hC03FFFFFC0000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3556901\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h38100000007BFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3557515\n"); + end + x = 64'hBFBA38B46A6BC45C; + y = 64'hB5700001FFEFFFFF; + z = 64'h0010000400001FFE; + ans = 64'h353A38B7B16818F3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3558129\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3558743\n"); + end + x = 64'hC1FFFFFFFFFF000F; + y = 64'h401FF0000007FFFF; + z = 64'hC010000000000000; + ans = 64'hC22FF000000F008E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3559357\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hC1E0EEDC0A56584A; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3559971\n"); + end + x = 64'hC3E0000000DFFFFF; + y = 64'hBFB004000001FFFF; + z = 64'h401EFDFFFFFFFFFF; + ans = 64'h43A0040000E237FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3560585\n"); + end + x = 64'h3BDFFFFFFFFFFFFF; + y = 64'h0000000000000001; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3561199\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h3F10000010040000; + z = 64'hB80000000203FFFF; + ans = 64'hB80000000203FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3561813\n"); + end + x = 64'hC756C2BB148137AE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h47F1999FB520B400; + ans = 64'h47F1999FB520B400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3562427\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hFFDFFF00000007FF; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3563041\n"); + end + x = 64'h3CAFFDFFFFFDFFFE; + y = 64'hC05FE0000000FFFF; + z = 64'hBFBFFBFFFEFFFFFE; + ans = 64'hBFBFFBFFFF0007F6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3563655\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h0010000000000001; + z = 64'h0000000000000000; + ans = 64'h8000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3564269\n"); + end + x = 64'hA589D73A50255699; + y = 64'hBFBDFFFFFFFFFFEF; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3564883\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hB80000000000103F; + ans = 64'hB80000000000103F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3565497\n"); + end + x = 64'h599A418CB6682652; + y = 64'h38185008F1338C4A; + z = 64'hFFD1FFFFFFFFFBFE; + ans = 64'hFFD1FFFFFFFFFBFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3566111\n"); + end + x = 64'h401676FE6363B6AF; + y = 64'h3CA0000000000000; + z = 64'h3CA0000000000001; + ans = 64'h3CCA76FE6363B6AF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3566725\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h40066A7122CE9B43; + z = 64'hBFFFFFBFFFFBFFFE; + ans = 64'hBFFFFFBFFFFBFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3567339\n"); + end + x = 64'hB80D7AECC874C39B; + y = 64'h3CA0000000000001; + z = 64'h37E000080001FFFF; + ans = 64'h37E000080001FFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3567953\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h37F0000007FFE000; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3568567\n"); + end + x = 64'h5800000007FFFEFF; + y = 64'h47F3EFFFFFFFFFFE; + z = 64'h251000040000003E; + ans = 64'h6003F00009F7FEBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3569181\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3569795\n"); + end + x = 64'hC1E0000001FDFFFF; + y = 64'hC61EFFFFFFFFFFFB; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'h480F000003DC1FF9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3570409\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h3FD0000000000001; + z = 64'hD75001FFFFFFF7FE; + ans = 64'hD75001FFFFFFF7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3571023\n"); + end + x = 64'hB4500A9B355B9DA1; + y = 64'h434FDFFFFFFFFF00; + z = 64'h802A66CCDA332D0A; + ans = 64'hB7AFF521344C8306; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3571637\n"); + end + x = 64'h47FFFFFFFFFFE000; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h47EFFFFFFFFFDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3572251\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hC3F00000FBFFFFFF; + z = 64'hC020008000080000; + ans = 64'hC020008000080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3572865\n"); + end + x = 64'h40C00E9357F1C66A; + y = 64'h3FE0000000000000; + z = 64'h840000000008007F; + ans = 64'h40B00E9357F1C66A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3573479\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hBFC01BFFFFFFFFFE; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3574093\n"); + end + x = 64'h4019103C1A2007AE; + y = 64'hC1E000000001DFFE; + z = 64'h7FEFFFFFFEDFFFFF; + ans = 64'h7FEFFFFFFEDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3574707\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3575321\n"); + end + x = 64'hC010003FFDFFFFFE; + y = 64'h380F7FFFFFFFE000; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3575935\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h3FF0000000000000; + z = 64'hFFEB2A3DD30E39A1; + ans = 64'hFFEB2A3DD30E39A1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3576549\n"); + end + x = 64'h3FFFFFE003FFFFFF; + y = 64'h43E5002C3E9728BF; + z = 64'hC1CFE0000001FFFE; + ans = 64'h43F500174106F3AF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3577163\n"); + end + x = 64'hBFD000007FFF7FFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'hBFE000007FFF7FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3577777\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h3FD0000004FFFFFF; + z = 64'h37ED063ED7FADEC0; + ans = 64'h37ED063ED7FADEC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3578391\n"); + end + x = 64'hBFDFFDFFFFFFDFFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC347ACB97EB17C3A; + ans = 64'hC347ACB97EB17C3A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3579005\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h40F00000007FBFFF; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3579619\n"); + end + x = 64'hC1C00000017FFFFF; + y = 64'hC0301EFFFFFFFFFE; + z = 64'hC4AFFFFBFFFFFFFD; + ans = 64'hC4AFFFFBFFFFFBF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3580233\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h4000000000000001; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3580847\n"); + end + x = 64'hB6DFFB8000000000; + y = 64'hC05FFFFFFFFDFFC0; + z = 64'hBFE0000000000000; + ans = 64'hBFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3581461\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h4010002000000003; + ans = 64'h4010002000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3582075\n"); + end + x = 64'hB7E0000000802000; + y = 64'hCB5007FFFFFFF800; + z = 64'h409FFFDFFFFBFFFF; + ans = 64'h4340080000805C10; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3582689\n"); + end + x = 64'h3FE00000001FFFFD; + y = 64'h4010000000000001; + z = 64'h0000000000000000; + ans = 64'h40000000001FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3583303\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h37EFF00004000000; + z = 64'hC80001003FFFFFFE; + ans = 64'hC80001003FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3583917\n"); + end + x = 64'hC007800000000000; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hC1CB8195F37757A9; + ans = 64'hC1CB8195FF3757A9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3584531\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h4010B67191C48B15; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3585145\n"); + end + x = 64'h3835086F8A7930D6; + y = 64'h400F7BFFFFFFFFFF; + z = 64'h45AFFFFFFFFFFDFF; + ans = 64'h45AFFFFFFFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3585759\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h4340000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3586373\n"); + end + x = 64'hCEF000000207FFFF; + y = 64'hC05CDD77E0D1432A; + z = 64'hBFD0000000000001; + ans = 64'h4F5CDD77E47B60E0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3586987\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h403BFFFFFFFFFFBE; + ans = 64'h403BFFFFFFFFFFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3587601\n"); + end + x = 64'hB81E7FFFFFFFFFFF; + y = 64'h4D410000FFFFFFFE; + z = 64'hC3EFFFFFFF7FF7FF; + ans = 64'hC570340103FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3588215\n"); + end + x = 64'h1FE0FFBFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3588829\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hC3CFFFE000007FFF; + ans = 64'hC3CFFFE000007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3589443\n"); + end + x = 64'hBFC391E68E64E4C7; + y = 64'h7FE0000000000001; + z = 64'h28E07F7FFFFFFFFE; + ans = 64'hFFB391E68E64E4C8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3590057\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h3FE11F532437EC3E; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3590671\n"); + end + x = 64'h44A0000023FFFFFF; + y = 64'hC3C0010000080000; + z = 64'h8019FFFFFFFFFFFF; + ans = 64'hC8700100240A3FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3591285\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hC010000000000001; + ans = 64'hC027FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3591899\n"); + end + x = 64'h402FFFFFFFFFFFEC; + y = 64'h380FFFFE00FFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3592513\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h7FF0000000000001; + z = 64'h46E0000021000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3593127\n"); + end + x = 64'h4020000100000000; + y = 64'h3D4FB80000000000; + z = 64'h38007FFFFFFFF7FF; + ans = 64'h3D7FB801FB800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3593741\n"); + end + x = 64'h43D017FFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3594355\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hC0500003FFE00000; + z = 64'h448357C41790A530; + ans = 64'h448357C41790A530; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3594969\n"); + end + x = 64'h7FCCADFDE13D2A89; + y = 64'h8000000000000000; + z = 64'hC00EFFFFFFFEFFFF; + ans = 64'hC00EFFFFFFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3595583\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h3C6F000000000FFF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3596197\n"); + end + x = 64'hB816C47C77CD4FB9; + y = 64'h3CA0000000001001; + z = 64'h43FFFFFFFDFFFEFF; + ans = 64'h43FFFFFFFDFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3596811\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3597425\n"); + end + x = 64'hB7F00005FFFFFFFF; + y = 64'h7FFFFFFFFFE0007F; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFE0007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3598039\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h8010000000000000; + z = 64'hBFC0000000000000; + ans = 64'hBFC0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3598653\n"); + end + x = 64'h1B400000000FFF7F; + y = 64'h3CAFFFFFFC00FFFE; + z = 64'hB80FFFFEFFFFFF7F; + ans = 64'hB80FFFFEFFFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3599267\n"); + end + x = 64'hC3DC5B44CF32758F; + y = 64'h8010000000000001; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3599881\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hC03141D1BA830FA0; + z = 64'h432FFC0000010000; + ans = 64'h432FFC0000010000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3600495\n"); + end + x = 64'hC7FFFDFFEFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h41DFFFFDFDFFFFFF; + ans = 64'h41DFFFFDFDFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3601109\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h41CFFFFFE000001E; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3601723\n"); + end + x = 64'h37EFFFFFFFFFFBFF; + y = 64'h37EFFFDFFFFF7FFE; + z = 64'h43E0000000008040; + ans = 64'h43E0000000008040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3602337\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hBCA0000000000001; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3602951\n"); + end + x = 64'hBA5FFFFFF00007FE; + y = 64'h401100007FFFFFFF; + z = 64'h8010000000000000; + ans = 64'hBA810000778003FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3603565\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hFFFF9F277AF39F4A; + ans = 64'hFFFF9F277AF39F4A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3604179\n"); + end + x = 64'h4340018000000000; + y = 64'h3FB01B3E7CDC5A25; + z = 64'h43FD6361F6FE7D6F; + ans = 64'h43FD6382308092DF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3604793\n"); + end + x = 64'hC3DFFFFFFFFFEFDF; + y = 64'hBFD0000000000000; + z = 64'hC340000000000000; + ans = 64'h43BFDFFFFFFFEFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3605407\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hBFCF0A649CE7E379; + z = 64'hBFE07F0000000000; + ans = 64'hBFE07F0000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3606021\n"); + end + x = 64'hB7F012DE7CF1AB19; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h47F000003FFFFF7F; + ans = 64'h47F000003FFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3606635\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hFCA0000FBFFFFFFE; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3607249\n"); + end + x = 64'hBFB6A48CB024F7A8; + y = 64'hC030000040100000; + z = 64'h52F88B314F472C55; + ans = 64'h52F88B314F472C55; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3607863\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hBFE0000000000000; + z = 64'hBFF0000000000000; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3608477\n"); + end + x = 64'hCE7FFFEBFFFFFFFF; + y = 64'hBCAC4284F9FA3266; + z = 64'h8000000000000001; + ans = 64'h4B3C427350671629; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3609091\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hC03FFFFFFFFF1000; + ans = 64'hC03FFFFFFFFF1000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3609705\n"); + end + x = 64'h4006C48B197B2BCB; + y = 64'h43DFF7FFFFFFBFFF; + z = 64'h92623F346F64078A; + ans = 64'h43F6BED9F6B49F76; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3610319\n"); + end + x = 64'h3EE00000000BFFFE; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hC010000000000001; + ans = 64'hC010000200000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3610933\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h402FFFFEFFFFF7FF; + z = 64'hC1FFFEFFFFFFF800; + ans = 64'hC1FFFEFFFFFFF800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3611547\n"); + end + x = 64'hC0389D70C7422759; + y = 64'hBFF0000000000001; + z = 64'hC1E0001FFFFFFFFE; + ans = 64'hC1E0001FFCEC51E5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3612161\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h43FFFFEFFDFFFFFF; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3612775\n"); + end + x = 64'h3FE8EEBA01E48447; + y = 64'hC2BFFFFFF800007F; + z = 64'h424AC7A4E57541D9; + ans = 64'hC2B8B92AB1DDEBA6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3613389\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3614003\n"); + end + x = 64'hC01FFFC00000007E; + y = 64'hC1FFDFFFBFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3614617\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hC000000000000001; + z = 64'hB7F9DEF92C81623D; + ans = 64'hB7F9DEF92C81623D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3615231\n"); + end + x = 64'h401FFFFFFFDE0000; + y = 64'h43C0000000007FFC; + z = 64'hC1D1FFFFFFFFFFFB; + ans = 64'h43EFFFFFFFD5FFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3615845\n"); + end + x = 64'h2D50000000FFFFBE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3616459\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hCA7FBFFFFFFF7FFF; + z = 64'h0010000000002000; + ans = 64'h0AAFBFFFFFFF7FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3617073\n"); + end + x = 64'hC0607FFBFFFFFFFF; + y = 64'hC010000000000000; + z = 64'h3FFFFFCFFFFFFFFE; + ans = 64'h40808FFBE7FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3617687\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h43DFFFE003FFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3618301\n"); + end + x = 64'h4590000007FF7FFF; + y = 64'hC1C86A12F7EE0253; + z = 64'h43C10000007FFFFF; + ans = 64'hC7686A130422487D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3618915\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3619529\n"); + end + x = 64'h402D80C8C9A07C22; + y = 64'h3FD001FFFC000000; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3620143\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hC340000000000000; + z = 64'h0F9FFFFFFF000010; + ans = 64'h0F9FFFFFFF000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3620757\n"); + end + x = 64'hBCAFFF80FFFFFFFF; + y = 64'hF4540CFEF492C4F9; + z = 64'h43DFFFDFF7FFFFFE; + ans = 64'h71140CAF60FEEA52; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3621371\n"); + end + x = 64'hC8076B4F59C23E85; + y = 64'hC340000000000001; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'h4B576B4F59C23E86; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3621985\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hCA30000000000080; + z = 64'h3FCDFFFFFFFFFFFC; + ans = 64'h3FCDFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3622599\n"); + end + x = 64'hC0E18338554B04B7; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3EEFFFFFFEFDFFFF; + ans = 64'h44418338554B04B6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3623213\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hDC7FFFFC3FFFFFFE; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'h1CAFFFFC3FFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3623827\n"); + end + x = 64'h3D25024D4C68C3B0; + y = 64'h3F4FFFFFC00007FF; + z = 64'hBF260C1D68A1C2F7; + ans = 64'hBF260C1D68A1BDB6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3624441\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hFFE0000000000001; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3625055\n"); + end + x = 64'h299FFFFFFFFFFA00; + y = 64'h241FFFFFFDFFFFF7; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3625669\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h381FFFFFDBFFFFFF; + ans = 64'h401FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3626283\n"); + end + x = 64'h3C03D19D713896A0; + y = 64'h43D0000001FFF7FF; + z = 64'h40FFDFFFFFFFBFFF; + ans = 64'h40FFE009E8CE79D8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3626897\n"); + end + x = 64'h755077FFFFFFFFFE; + y = 64'hFFF0000000000000; + z = 64'hBFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3627511\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h55F901489896FD56; + z = 64'h3FC8AE7AC3754886; + ans = 64'h3FC8AE7AC3754886; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3628125\n"); + end + x = 64'h3EAFFFFFDFF00000; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hBFFFFFFBFFFFFFFC; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3628739\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hB5E0010200000000; + z = 64'h0010000000000000; + ans = 64'h0010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3629353\n"); + end + x = 64'hC0DFFFFF80000001; + y = 64'h44CFFFFFFFF6FFFF; + z = 64'hC02FF25C504A2810; + ans = 64'hC5BFFFFF7FF70000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3629967\n"); + end + x = 64'hBCA0000000000000; + y = 64'h0000000000000000; + z = 64'hBCA0000000000000; + ans = 64'hBCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3630581\n"); + end + x = 64'hBE2FFE0000000008; + y = 64'h43DFFFFFFFFF7FFE; + z = 64'h4340000000000001; + ans = 64'h433FFFF800800002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3631195\n"); + end + x = 64'hBCA0000000000000; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h7FDFFFFFFFEFFFFC; + ans = 64'h7FDFFFFFFFEFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3631809\n"); + end + x = 64'h4FCFE00000000002; + y = 64'hB7F000000000103F; + z = 64'hB8089029A0EB5FB8; + ans = 64'hC7CFE00000002060; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3632423\n"); + end + x = 64'h402000007FFFFEFF; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hBFE0000000000001; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3633037\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFEFFFFFFFC00010; + z = 64'h332FFFFFFFFC07FF; + ans = 64'h3C9FFFFFFFC00010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3633651\n"); + end + x = 64'hC032000000000003; + y = 64'h0010000000000001; + z = 64'hBE5003FFFFFDFFFE; + ans = 64'hBE5003FFFFFDFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3634265\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3FF000000FFFFFF7; + z = 64'h0000000000000001; + ans = 64'hBCA000000FFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3634879\n"); + end + x = 64'hC01FFFF800000200; + y = 64'h401001FFFF7FFFFF; + z = 64'hF210000040FFFFFF; + ans = 64'hF210000040FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3635493\n"); + end + x = 64'hBCA0000000000000; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h8010000000000001; + ans = 64'h8010000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3636107\n"); + end + x = 64'h00000081FFFFFFFF; + y = 64'hC7EFFFFFFF7EFFFF; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3636721\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3CA0000000000001; + z = 64'hF7A0000080FFFFFE; + ans = 64'hF7A0000080FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3637335\n"); + end + x = 64'hC02918C49CF43452; + y = 64'h7FFFFFFFFFFFFEFC; + z = 64'h402FFFFFFFE00080; + ans = 64'h7FFFFFFFFFFFFEFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3637949\n"); + end + x = 64'h8020000C00000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3638563\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC03FFFE00000001E; + z = 64'h41C007FFFFFFDFFE; + ans = 64'h41C007FFFFFFDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3639177\n"); + end + x = 64'hFFF400000000001E; + y = 64'h3FD0000000000000; + z = 64'h9749F8042A7828F1; + ans = 64'hFFFC00000000001E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3639791\n"); + end + x = 64'hBCA0000000000000; + y = 64'h37EFFFFF7FEFFFFF; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3640405\n"); + end + x = 64'hBF0000EFFFFFFFFF; + y = 64'hC77FFFFFFFF5FFFE; + z = 64'hC2200003F7FFFFFF; + ans = 64'h469000EFFFFAFFB3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3641019\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'hBC8FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3641633\n"); + end + x = 64'hC1FFFFFFFF0FFFFE; + y = 64'hB80FFFE0001FFFFF; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3642247\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3FE0000000000000; + z = 64'hBFBFF7FFFF000000; + ans = 64'hBFBFF7FFFF000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3642861\n"); + end + x = 64'hBE2D7F50748E2E92; + y = 64'hB3A004000000003E; + z = 64'hBDD00000800FFFFF; + ans = 64'hBDD00000800FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3643475\n"); + end + x = 64'h401FFFE000000004; + y = 64'h3FE0000000000001; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'h400FFFE000000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3644089\n"); + end + x = 64'hBCA0000000000000; + y = 64'h47FFFFFC00001FFF; + z = 64'hBD77EABF70AF8DAD; + ans = 64'hC4AFFFFC00001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3644703\n"); + end + x = 64'h403FFF8002000000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h324FFFFFFFF8000E; + ans = 64'h403FFF8001FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3645317\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3FBFFFFFFFFBBFFE; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3645931\n"); + end + x = 64'hEDCFFBFFFFFFFFBF; + y = 64'hC00FC02000000000; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h6DEFBC27FBFFFFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3646545\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3FF0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3647159\n"); + end + x = 64'h4E80C21A53CEB830; + y = 64'h3FAFFFFFFFDF7FFE; + z = 64'h4000000000000000; + ans = 64'h4E40C21A53BDB30C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3647773\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h403EFFFFFFFFFFFB; + ans = 64'h403EFFFFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3648387\n"); + end + x = 64'hC0EC000080000000; + y = 64'hFFEFFFFF7FC00000; + z = 64'h3CA00000000003FB; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3649001\n"); + end + x = 64'hC3FFC0001FFFFFFF; + y = 64'h4000000000000000; + z = 64'hBCA0000000000000; + ans = 64'hC40FC0001FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3649615\n"); + end + x = 64'hBCA0000000000000; + y = 64'h402FFBFFFFFFFFFF; + z = 64'hC1D66071D432CFE3; + ans = 64'hC1D66071D432CFE3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3650229\n"); + end + x = 64'h3FC0000000100008; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hC00FFFFFFE000006; + ans = 64'hC00BFFFFFDFC0004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3650843\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC3C00007FFFF8000; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3651457\n"); + end + x = 64'h38163F4BCFE61288; + y = 64'h3FDFFFF001FFFFFE; + z = 64'hBF5FFF7FFFFFFFFB; + ans = 64'hBF5FFF7FFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3652071\n"); + end + x = 64'hBCA0000000000000; + y = 64'h4010000000000000; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3652685\n"); + end + x = 64'h801FFBFFFFFDFFFE; + y = 64'hBFDBA8444505653F; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3653299\n"); + end + x = 64'hBCA0000000000000; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hC00FDFFFFFF00000; + ans = 64'hC00FDFFFFFF00002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3653913\n"); + end + x = 64'h7FFF00000000000F; + y = 64'h3FB400000000001F; + z = 64'hC03FFFFFFFDFFFF0; + ans = 64'h7FFF00000000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3654527\n"); + end + x = 64'hBFD0080000000020; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h8010000000000001; + ans = 64'hC00008000000001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3655141\n"); + end + x = 64'hBCA0000000000000; + y = 64'h41E0FFFFFFFFFFFA; + z = 64'hBFF26B5D87C2CB8D; + ans = 64'hBFF26B5DCBC2CB8D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3655755\n"); + end + x = 64'h43C0020000400000; + y = 64'h4340000000000001; + z = 64'hC34DBA2051ED9A0F; + ans = 64'h4710020000400001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3656369\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3FC000FFFFFFFF80; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3656983\n"); + end + x = 64'hBFFFFFE400000000; + y = 64'hBFDBD54407F5B2BC; + z = 64'hC02FFFFFFFFDFFF0; + ans = 64'hC02E42AD45285D34; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3657597\n"); + end + x = 64'hBCA0000000000000; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3658211\n"); + end + x = 64'h3FB25318C481E7CE; + y = 64'h480B6030B392D965; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h47CF5A64272A6473; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3658825\n"); + end + x = 64'hBCA0000000000000; + y = 64'h7FE0000000000000; + z = 64'h3CA0FFF800000000; + ans = 64'hFC90000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3659439\n"); + end + x = 64'hBC207E0000000000; + y = 64'hC021000000001FFF; + z = 64'h7FFD3A97BA6B9782; + ans = 64'h7FFD3A97BA6B9782; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3660053\n"); + end + x = 64'h3FD00000007FFBFF; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h7FD00000007FFBFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3660667\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC7E000008003FFFF; + z = 64'h403645F83349B39B; + ans = 64'h449000008003FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3661281\n"); + end + x = 64'hC3EF14FFEB0F3D07; + y = 64'h7FF0000000000000; + z = 64'h801AD5E676A26F15; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3661895\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFDFE007FFFFFFFF; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3662509\n"); + end + x = 64'hBFB45FC3AA5813AC; + y = 64'h37EFFFE000004000; + z = 64'hBEC0000007EFFFFE; + ans = 64'hBEC0000007EFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3663123\n"); + end + x = 64'hBCA0000000000000; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3663737\n"); + end + x = 64'h000FFFFBFFFFFFBE; + y = 64'h7FEBB7B174CBCB9B; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h400FB7AA86DF6DF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3664351\n"); + end + x = 64'hBCA0000000000000; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h001639C0ADB56178; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3664965\n"); + end + x = 64'h4002EFFA98BD895F; + y = 64'h3FD0000000000FDF; + z = 64'hE5D04000000003FF; + ans = 64'hE5D04000000003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3665579\n"); + end + x = 64'hDB1D604C1DB49326; + y = 64'h8000000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3666193\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFFFFFFFFFFE000F; + z = 64'hD0D0000000017FFF; + ans = 64'hD0D0000000017FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3666807\n"); + end + x = 64'hC010000001F00000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hBA469C50554556D4; + ans = 64'hBA469C50554556D4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3667421\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3F29FEBD6B0F049C; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3668035\n"); + end + x = 64'hBFE0FFFFFC000000; + y = 64'hC1C0001FFFDFFFFF; + z = 64'h7FD00040000007FF; + ans = 64'h7FD00040000007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3668649\n"); + end + x = 64'hBCA0000000000000; + y = 64'h8010000000000001; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3669263\n"); + end + x = 64'hC1EC010F446540A4; + y = 64'hBAC6852416F9C589; + z = 64'h3FD0000000000000; + ans = 64'h3FD000000000000A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3669877\n"); + end + x = 64'hBCA0000000000000; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hF7C00000043FFFFE; + ans = 64'hF7C00000043FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3670491\n"); + end + x = 64'hC2E2654CDB87DD48; + y = 64'hC02FFFFFFFFE7FFF; + z = 64'hB750040000000010; + ans = 64'h4322654CDB870088; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3671105\n"); + end + x = 64'h3F7FFFFFFFF0001E; + y = 64'hBCA0000000000000; + z = 64'h7FF0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3671719\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC039C87DD7926BBE; + z = 64'h41F000041FFFFFFF; + ans = 64'h41F000041FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3672333\n"); + end + x = 64'hB80FFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h800000000007FBFE; + ans = 64'h34CFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3672947\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFE2000000000003; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3673561\n"); + end + x = 64'h4880000000087FFE; + y = 64'hEA400800007FFFFE; + z = 64'hC345D14186A8EEB1; + ans = 64'hF2D008000088843C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3674175\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFD0000000000000; + z = 64'h4010000000000000; + ans = 64'h4010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3674789\n"); + end + x = 64'hC00F800001000000; + y = 64'h4000080000000FFF; + z = 64'h3CA0000000000001; + ans = 64'hC01F8FC001009F7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3675403\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFD0000000000001; + z = 64'hBAB000000000FF7E; + ans = 64'h3C7FFFFFFF000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3676017\n"); + end + x = 64'h400FE01000000000; + y = 64'hBFEFFFFFDF000000; + z = 64'h27F0000000002000; + ans = 64'hC00FE00FDF20EF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3676631\n"); + end + x = 64'h3FB007FFFFFFFFDF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3677245\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBA13FDFFFFFFFFFE; + z = 64'h000FFFFFFE200000; + ans = 64'h36C3FDFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3677859\n"); + end + x = 64'h41D86E890469D30F; + y = 64'hBFE0000000000000; + z = 64'hC03205A669DCD5C0; + ans = 64'hC1C86E890D6CA644; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3678473\n"); + end + x = 64'hBCA0000000000000; + y = 64'h7FDF03FFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hFC8F03FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3679087\n"); + end + x = 64'h7FE00077FFFFFFFE; + y = 64'h40E000001000001E; + z = 64'hBFD4FFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3679701\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h4000000000000001; + ans = 64'h4000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3680315\n"); + end + x = 64'h4800DF1F660F56AF; + y = 64'hDE3FFFFFFFFFB000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hE650DF1F660F2C81; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3680929\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFF0000000000000; + z = 64'h3E59A41A8D3F0D0E; + ans = 64'h3E59A41A8F3F0D0E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3681543\n"); + end + x = 64'h31DC2BE698BED132; + y = 64'h3FA0000400000001; + z = 64'hC03FFF8001FFFFFF; + ans = 64'hC03FFF8001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3682157\n"); + end + x = 64'hC0A31FC8DABA02AD; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h43500000000004C7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3682771\n"); + end + x = 64'hBCA0000000000000; + y = 64'h47E943885C8C6553; + z = 64'hC1FEE2CEB74B7C2D; + ans = 64'hC49943885C8C6D0C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3683385\n"); + end + x = 64'h42C9F7BB6D642AEB; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h7FF01D9CEB412063; + ans = 64'h7FF81D9CEB412063; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3683999\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFD12DBE8A52106B; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3684613\n"); + end + x = 64'hBFADA801A13F62D4; + y = 64'h402FDFFFFFFFEFFF; + z = 64'h43F00001FFFF8000; + ans = 64'h43F00001FFFF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3685227\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3685841\n"); + end + x = 64'h3FC0000000800080; + y = 64'hC7E0000FFFF00000; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'hC7B0001000700100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3686455\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h41DFFFFFFF7FFEFF; + ans = 64'h41DFFFFFFF7FFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3687069\n"); + end + x = 64'h6CD0010003FFFFFF; + y = 64'hC1E000000FFFFFFF; + z = 64'hB5A0003FFFFBFFFF; + ans = 64'hEEC0010014010002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3687683\n"); + end + x = 64'hB810FFFFBFFFFFFF; + y = 64'hC010000000000001; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h401FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3688297\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC3EFC04000000000; + z = 64'h43EFFFBFFFFFFF7F; + ans = 64'h43EFFFBFFFFFFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3688911\n"); + end + x = 64'h99B00008000FFFFE; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hBE4FF80000007FFF; + ans = 64'hBE4FF80000007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3689525\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC451238B3FAD72A9; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'h410123873FAD72A9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3690139\n"); + end + x = 64'h3FEB03EBAD17DB6E; + y = 64'h434FFFFD7FFFFFFF; + z = 64'hC2951E9EDCF540CE; + ans = 64'h434B0145BCEDD33F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3690753\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC340000000000001; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3691367\n"); + end + x = 64'h0005E0458A43FBDB; + y = 64'h7FDFFFBFFFFFFFFF; + z = 64'h0000000000000000; + ans = 64'h3FE780E726E39D4B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3691981\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h3FF0000002000003; + ans = 64'h4008000001000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3692595\n"); + end + x = 64'h3FF0000000000043; + y = 64'h3FFD92E157246295; + z = 64'h00205FFFFFFFFFFF; + ans = 64'h3FFD92E157246311; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3693209\n"); + end + x = 64'hC2DFFFFFBFF7FFFF; + y = 64'hFFE0000000000000; + z = 64'h4010000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3693823\n"); + end + x = 64'hBCA0000000000000; + y = 64'h47E02D7CE2B31E42; + z = 64'h3FDFFFFEFFFFFFFF; + ans = 64'hC4902D7CE2B31E42; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3694437\n"); + end + x = 64'h4AD0000000010400; + y = 64'hFFE0000000000001; + z = 64'hC01FFFFFFFFFFB80; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3695051\n"); + end + x = 64'hBCA0000000000000; + y = 64'h35A00080FFFFFFFF; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3695665\n"); + end + x = 64'hBCAFFFFFE00001FF; + y = 64'h3283FE0000000000; + z = 64'hC02F7FFFFFFFFEFF; + ans = 64'hC02F7FFFFFFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3696279\n"); + end + x = 64'hBCA0000000000000; + y = 64'hFFF0000000000000; + z = 64'h3FE0000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3696893\n"); + end + x = 64'h43EFFFFDFFFDFFFF; + y = 64'hBFBFFFFFE0000003; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3697507\n"); + end + x = 64'hBCA0000000000000; + y = 64'hFFF0000000000001; + z = 64'h43DBFFFFFFFFFFF7; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3698121\n"); + end + x = 64'h3FC0000203FFFFFE; + y = 64'h4398F59E6CA7D49A; + z = 64'hBF9FF3DF6A07BBD1; + ans = 64'h4368F5A1919909C7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3698735\n"); + end + x = 64'hFFFFFEFFFFFBFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h4000000000000001; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3699349\n"); + end + x = 64'hBCA0000000000001; + y = 64'h001000004000007F; + z = 64'h41C007FFFFEFFFFF; + ans = 64'h41C007FFFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3699963\n"); + end + x = 64'hAD45032AE4153B5D; + y = 64'h0000000000000000; + z = 64'h3FDFFBFFBFFFFFFF; + ans = 64'h3FDFFBFFBFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3700577\n"); + end + x = 64'hBCA0000000000001; + y = 64'hC0A0000001FFFFEF; + z = 64'hBCA0000000000001; + ans = 64'h3D4FFC0003FFFFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3701191\n"); + end + x = 64'hFFE01FFFDFFFFFFF; + y = 64'hB80007FFFFFFFFF7; + z = 64'hBFE4001FFFFFFFFE; + ans = 64'h77F0280FDFEFFFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3701805\n"); + end + x = 64'hBCA0000000000001; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3702419\n"); + end + x = 64'hC7E00000F7FFFFFF; + y = 64'h3E22A58881822F6B; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3703033\n"); + end + x = 64'hBCA0000000000001; + y = 64'h0010000000000000; + z = 64'h05CF952FB7C9E1F0; + ans = 64'h05CF952FB7C9E1F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3703647\n"); + end + x = 64'h3FFFFE0000FFFFFF; + y = 64'h35503FFFFFFFFFFE; + z = 64'hC020000000300000; + ans = 64'hC020000000300000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3704261\n"); + end + x = 64'h47EF01BF46D247DB; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3704875\n"); + end + x = 64'hBCA0000000000001; + y = 64'h002BFFFFFFFFFFFB; + z = 64'hBFC0000100000002; + ans = 64'hBFC0000100000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3705489\n"); + end + x = 64'h400FFFF000002000; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hBE300C0000000000; + ans = 64'hBE300C0000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3706103\n"); + end + x = 64'hBCA0000000000001; + y = 64'h41EF00007FFFFFFE; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'hBE9F000080000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3706717\n"); + end + x = 64'h3E300000001FE000; + y = 64'hC030000008000000; + z = 64'h40CFFFDFFFFFFFF7; + ans = 64'h40CFFFDFFFFF7FF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3707331\n"); end x = 64'hBCA0000000000001; y = 64'h3CAFFFFFFFFFFFFF; @@ -86470,12 +283870,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3703745\n"); + $fwrite(fp,"3707945\n"); end - x = 64'h37E01000000000FF; - y = 64'h3FD0000000000000; - z = 64'h4019662DF874E479; - ans = 64'h4019662DF874E479; + x = 64'h5AE01000000000FF; + y = 64'hB7E000000000000B; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hD2D010000000010A; rn = 1; rz = 0; rm = 0; @@ -86517,59 +283917,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3705759\n"); - end - x = 64'hBE6DFFFFFFFFFF7E; - y = 64'hC0A555407160BC9B; - z = 64'h3FFEB19129135086; - ans = 64'h3FFEB2312876A2DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3707773\n"); + $fwrite(fp,"3708559\n"); end x = 64'hBCA0000000000001; - y = 64'h3FE0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hBF600010003FFFFF; + ans = 64'hBF600010003FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3709173\n"); + end + x = 64'h3FC0100000001000; + y = 64'h3FBFFDFFFFFFFFFB; + z = 64'h3F68007FFFFFFFFF; + ans = 64'h3F930F0F00000FFC; rn = 1; rz = 0; rm = 0; @@ -86613,10 +284013,10 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"3709787\n"); end - x = 64'hB800400000FFFFFF; - y = 64'h3FF0000000000000; - z = 64'hBF8001000000007F; - ans = 64'hBF8001000000007F; + x = 64'hBFA0000000100003; + y = 64'h3FD0000000000001; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFBFFFFFFFBFFE; rn = 1; rz = 0; rm = 0; @@ -86658,12 +284058,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3711801\n"); + $fwrite(fp,"3710401\n"); end - x = 64'h3F7FFFFFFFFFF7FC; - y = 64'hC1E1FFFFFFFFFFDE; - z = 64'hC03FFFFF80000400; - ans = 64'hC1720001FFFFF35C; + x = 64'hBCA0000000000001; + y = 64'h483000000FFFDFFF; + z = 64'hC1F2000000000008; + ans = 64'hC4E000000FFFE024; rn = 1; rz = 0; rm = 0; @@ -86705,12 +284105,670 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3713815\n"); + $fwrite(fp,"3711015\n"); + end + x = 64'hFFFE0A678C624F99; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h44A36355884BDF32; + ans = 64'hFFFE0A678C624F99; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3711629\n"); + end + x = 64'hBCA0000000000001; + y = 64'h7FF03FC000000000; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h7FF83FC000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3712243\n"); + end + x = 64'h4194827E2F7BD16C; + y = 64'hC90FFFFFFFFFE800; + z = 64'hC3DF000000000008; + ans = 64'hCAB4827E2F7BC20A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3712857\n"); + end + x = 64'hBCA0000000000001; + y = 64'h3FE0000000000001; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'hBC90000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3713471\n"); + end + x = 64'hC040003FEFFFFFFF; + y = 64'h3FDFFFFFFFFF8000; + z = 64'hC340000000000000; + ans = 64'hC340000000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3714085\n"); + end + x = 64'hBCA0000000000001; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hBFF0400000000400; + ans = 64'hBFF0400000000401; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3714699\n"); + end + x = 64'h38000000000005FF; + y = 64'hFFEFFFF7FFFFFFF7; + z = 64'hC6C0000120000000; + ans = 64'hF7FFFFF800000BF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3715313\n"); + end + x = 64'h802000000001FFF7; + y = 64'h3FF0000000000000; + z = 64'h3FE0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3715927\n"); + end + x = 64'hBCA0000000000001; + y = 64'hC02E0D532183CA7C; + z = 64'h3FCD7D34563A15FD; + ans = 64'h3FCD7D34563A1639; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3716541\n"); + end + x = 64'hEB5FFFFFDFBFFFFF; + y = 64'h3FF0000000000001; + z = 64'h409CBF6F4C076C92; + ans = 64'hEB5FFFFFDFC00001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3717155\n"); + end + x = 64'hBCA0000000000001; + y = 64'h000FFFFFC000001E; + z = 64'h8000000000000000; + ans = 64'h8000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3717769\n"); + end + x = 64'hBFBFDFFFFFFBFFFF; + y = 64'h41DFFFFFF0010000; + z = 64'hE69FFFBFFEFFFFFF; + ans = 64'hE69FFFBFFEFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3718383\n"); + end + x = 64'hBCA0000000000001; + y = 64'h4000000000000000; + z = 64'h0010000000000000; + ans = 64'hBCB0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3718997\n"); + end + x = 64'hC0D000000007FDFF; + y = 64'h41D00000FFFFF7FE; + z = 64'hC010000000000001; + ans = 64'hC2B000010007F9FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3719611\n"); end x = 64'hBCA0000000000001; y = 64'h4000000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + z = 64'hB84FBFFFFFFFFFFF; + ans = 64'hBCB0000000000002; rn = 1; rz = 0; rm = 0; @@ -86752,12 +284810,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3715829\n"); + $fwrite(fp,"3720225\n"); end - x = 64'hC34FFFFFE0000000; + x = 64'h3F8000000001FFFA; + y = 64'hFFEFFC000000001F; + z = 64'h50A000000001E000; + ans = 64'hFF7FFC000003FF93; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3720839\n"); + end + x = 64'h40E0240000000000; y = 64'h400FFFFFFFFFFFFE; - z = 64'h3F70003FFFFFFFFF; - ans = 64'hC36FFFFFDFFFFFFE; + z = 64'h3FD0000000000001; + ans = 64'h41002401FFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -86799,59 +284904,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3717843\n"); - end - x = 64'h3CAFFFE00FFFFFFE; - y = 64'h17600000BFFFFFFF; - z = 64'hBCB0000078000000; - ans = 64'hBCB0000078000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3719857\n"); + $fwrite(fp,"3721453\n"); end x = 64'hBCA0000000000001; - y = 64'h4340000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + y = 64'h802000003F7FFFFE; + z = 64'h38DFFFFFFFBFC000; + ans = 64'h38DFFFFFFFBFC000; rn = 1; rz = 0; rm = 0; @@ -86893,1516 +284951,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3721871\n"); + $fwrite(fp,"3722067\n"); end - x = 64'hBEC0008000003FFE; - y = 64'h434FFFFFFFFFFFFE; - z = 64'h3FB14DEC1EB3BA6A; - ans = 64'hC220008000001D61; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3723885\n"); - end - x = 64'h384FFF8FFFFFFFFE; - y = 64'hBFEE93E820EBFBFC; - z = 64'h3FE6840810AD9CD5; - ans = 64'h3FE6840810AD9CD5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3725899\n"); - end - x = 64'hBCA0000000000001; - y = 64'h7FF0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3727913\n"); - end - x = 64'hC3EF0000000000FE; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'h3F59E5826298B6A1; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3729927\n"); - end - x = 64'h47F000000200FFFE; - y = 64'hC03FFFEFFFDFFFFF; - z = 64'h40E004000000000E; - ans = 64'hC83FFFF003E1FDFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3731941\n"); - end - x = 64'hBCA0000000000001; - y = 64'h8010000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3733955\n"); - end - x = 64'hF322908E1375DFCB; - y = 64'h801FFFFFFFFFFFFF; - z = 64'h41F0000FFFFFFFFD; - ans = 64'h41F0000FFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3735969\n"); - end - x = 64'hC3F008000001FFFF; - y = 64'hC3FFFFFFFFFFEFFF; - z = 64'h800EFFFFFFFF7FFE; - ans = 64'h480008000001F7FA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3737983\n"); - end - x = 64'hBCA0000000000001; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3739997\n"); - end - x = 64'hC6BFFFFFFDFFFFC0; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'h4030200003FFFFFF; - ans = 64'h46AFFFFFFDFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3742011\n"); - end - x = 64'hC250000000001FFF; - y = 64'h8722F954FDAE09DB; - z = 64'hC7FFFFFFFE3FFFFF; - ans = 64'hC7FFFFFFFE3FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3744025\n"); - end - x = 64'hBCA0000000000001; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3746039\n"); - end - x = 64'hF3AFDFFFFEFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'hC09FFFFFB7FFFFFF; - ans = 64'h73BFDFFFFEFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3748053\n"); - end - x = 64'h0000FFFFBFFFFFFF; - y = 64'h14E13CBB39ACD32D; - z = 64'hB7E000000007FFFB; - ans = 64'hB7E000000007FFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3750067\n"); - end - x = 64'hBCA0000000000001; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CC8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3752081\n"); - end - x = 64'hB80FFFDFFFFBFFFF; - y = 64'hC010000000000001; - z = 64'hBFCFFFFFFFFFEFF7; - ans = 64'hBFCFFFFFFFFFEFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3754095\n"); - end - x = 64'hBFB0750627ECE045; - y = 64'hC3D94D7190159B0A; - z = 64'h78FFFFFFBFFFFFF7; - ans = 64'h78FFFFFFBFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3756109\n"); - end - x = 64'hBCA0000000000001; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3758123\n"); - end - x = 64'h43E93C2A6A97D86C; - y = 64'hFFE0000000000001; - z = 64'h43EFFFE000000004; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3760137\n"); - end - x = 64'hBFBFFFFFDFFFFDFE; - y = 64'h3F9C15102BF20E67; - z = 64'hFFF000400003FFFE; - ans = 64'hFFF800400003FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3762151\n"); - end - x = 64'hBCA0000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3764165\n"); - end - x = 64'h4B4396F138542460; - y = 64'h0000000000000000; - z = 64'h430000000FFFFDFF; - ans = 64'h430000000FFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3766179\n"); - end - x = 64'h453FFFFFFFFDFFFB; - y = 64'h3F41FFFFFF7FFFFE; - z = 64'h355000001FF7FFFF; - ans = 64'h4491FFFFFF7EDFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3768193\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; - y = 64'h0010000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3770207\n"); - end - x = 64'hC7EBE6A82D837A1D; - y = 64'h3CA0000000000000; - z = 64'h3FBFFF7FFF7FFFFF; - ans = 64'hC49BE6A82D837A1D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3772221\n"); - end - x = 64'h43E1000000040000; - y = 64'hBFB8B76BCDCA5E1B; - z = 64'h3FDFFFFFFFFF01FE; - ans = 64'hC3AA42E28AAD31D8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3774235\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FD0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCB4000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3776249\n"); - end - x = 64'h43F001FFFFEFFFFF; - y = 64'h3FE0000000000000; - z = 64'hC7F1FBFFFFFFFFFF; - ans = 64'hC7F1FBFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3778263\n"); - end - x = 64'hC1D0080000000800; - y = 64'h7FEFFFFC0000007F; - z = 64'hC80FFFBFFFFFDFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3780277\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FF0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3782291\n"); - end - x = 64'hC0C1001FFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hF8AFFFFFFFFFEF7F; - ans = 64'hF8AFFFFFFFFFEF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3784305\n"); - end - x = 64'hC3407FFFFEFFFFFF; - y = 64'hBFB9A56ED8CC7A8B; - z = 64'hC26080000000003F; - ans = 64'h430A6E7A4DF88770; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3786319\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; + x = 64'h4378DAD7F8CB6D2E; y = 64'h4010000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; + z = 64'hBFB007FFFFFEFFFF; + ans = 64'h4398DAD7F8CB6D2E; rn = 1; rz = 0; rm = 0; @@ -88444,5087 +284998,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3788333\n"); + $fwrite(fp,"3722681\n"); end - x = 64'h7FDFDFFFFFF7FFFF; - y = 64'h401FFFFFFFFFFFFE; - z = 64'h2251FB2DDFC8CEA1; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3790347\n"); - end - x = 64'hC2BF048ED04E91D1; - y = 64'h402000000FFFFDFF; - z = 64'h4CF04000000007FF; - ans = 64'h4CF04000000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3792361\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; - y = 64'h7FE0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3794375\n"); - end - x = 64'h3D50000000F7FFFF; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hC022000000001FFF; - ans = 64'h7D50000000F7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3796389\n"); - end - x = 64'hBFEFDFF7FFFFFFFF; - y = 64'hB39000007BFFFFFF; - z = 64'h3FCFF000001FFFFF; - ans = 64'h3FCFF000001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3798403\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; - y = 64'h8000000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3800417\n"); - end - x = 64'h425A6F792B92BECC; - y = 64'h800FFFFFFFFFFFFF; - z = 64'h3FC000FFFFFFFF80; - ans = 64'h3FC000FFFFFFFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3802431\n"); - end - x = 64'hBFC0000000800008; - y = 64'h43D0001000000002; - z = 64'hC3CFFFFBFFFF8000; - ans = 64'hC3D20000000FC011; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3804445\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3806459\n"); - end - x = 64'hC9F0000FFFFFFFFC; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'h4020020000000080; - ans = 64'h46B0000FFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3808473\n"); - end - x = 64'h510FFFFFFFFFFFFF; - y = 64'hC06FFF80000001FF; - z = 64'hC1C8B1703B19FD4B; - ans = 64'hD18FFF80000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3810487\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3812501\n"); - end - x = 64'h47FFFFFFFFC0FFFF; - y = 64'hBFE0000000000001; - z = 64'h40203FFFBFFFFFFE; - ans = 64'hC7EFFFFFFFC10001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3814515\n"); - end - x = 64'hC1F00080007FFFFE; - y = 64'h3FC000000000003B; - z = 64'h3FCFF80000000FFF; - ans = 64'hC1C0008000600839; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3816529\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3818543\n"); - end - x = 64'h3FE0000200010000; - y = 64'hC000000000000001; - z = 64'h43F000003FFFFFC0; - ans = 64'h43F000003FFFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3820557\n"); - end - x = 64'hC02000000000077E; - y = 64'hC7C2000000080000; - z = 64'hC03FFFFFC0000000; - ans = 64'h47F200000008086E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3822571\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3CDBFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3824585\n"); - end - x = 64'h7FF0000000001001; - y = 64'hC340000000000001; - z = 64'hBFDFFFFFBF7FFFFF; - ans = 64'h7FF8000000001001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3826599\n"); - end - x = 64'hBFDEED3A52F92CAE; - y = 64'hB7EF2623838B25E1; - z = 64'h7FDEFFBFFFFFFFFE; - ans = 64'h7FDEFFBFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3828613\n"); - end - x = 64'hBCAFFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h7CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3830627\n"); - end - x = 64'h3FF801FFFFFFFFFF; - y = 64'hFFF0000000000000; - z = 64'h4060010000000008; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3832641\n"); - end - x = 64'hBFFFFFFFFFFFBF7E; - y = 64'hC07F05AF578DC2B5; - z = 64'hB7E4F687E4E02EF6; - ans = 64'h408F05AF578D842C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3834655\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'h0000000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3836669\n"); - end - x = 64'h3FA0000007FFFF80; - y = 64'h0010000000000000; - z = 64'h40D00004000007FF; - ans = 64'h40D00004000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3838683\n"); - end - x = 64'h19CA7373ABD10AFC; - y = 64'h3D4010007FFFFFFE; - z = 64'hBFD0000004000000; - ans = 64'hBFD0000004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3840697\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'h3CA0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3842711\n"); - end - x = 64'hC3DFFFFFF000000F; - y = 64'h3FD0000000000000; - z = 64'h400000FFFEFFFFFF; - ans = 64'hC3BFFFFFF000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3844725\n"); - end - x = 64'h402FFFDFFBFFFFFE; - y = 64'hC4A00000003FFFFF; - z = 64'h3E4EDA17C4C51030; - ans = 64'hC4DFFFDFFC7FFF7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3846739\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'h3FE0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3C9FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3848753\n"); - end - x = 64'h400A345EEB63AB2B; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h3FC00001FFFFBFFF; - ans = 64'h400B345F0B63A729; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3850767\n"); - end - x = 64'hBFFA3A6CEF49B307; - y = 64'hC9603FFDFFFFFFFE; - z = 64'hC47FFFFF803FFFFF; - ans = 64'h496AA3535BB93BE7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3852781\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'h4000000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3854795\n"); - end - x = 64'h7FDFFFFFFF800004; - y = 64'h400FFFFFFFFFFFFE; - z = 64'hCB200000200FFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3856809\n"); - end - x = 64'hBFCBBA3F322084BE; - y = 64'hB7F48A14E108CB87; - z = 64'hFFDFFFFFFF000001; - ans = 64'hFFDFFFFFFF000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3858823\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'h4340000000000000; - z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3860837\n"); - end - x = 64'h3FA0000003FFFF7E; - y = 64'h434FFFFFFFFFFFFF; - z = 64'hC3D7FFFFFFFFFFFC; - ans = 64'hC3D7FF7FFFFFDFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3862851\n"); - end - x = 64'h3FEF869027739B45; - y = 64'h41C1000400000000; - z = 64'hBFDFFFFF6FFFFFFF; - ans = 64'h41C0BF8085876F6C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3864865\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3866879\n"); - end - x = 64'h47FFF7DFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hBFE00001FFFFFFFD; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3868893\n"); - end - x = 64'h7FF750D3ECFE8591; - y = 64'h30CFFBFFFFEFFFFF; - z = 64'hBE3FFFFFEFFFFFFD; - ans = 64'h7FFF50D3ECFE8591; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3870907\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3872921\n"); - end - x = 64'hC2703FE000000000; - y = 64'h801FFFFFFFFFFFFF; - z = 64'hC3C0001800000000; - ans = 64'hC3C0001800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3874935\n"); - end - x = 64'h7061412003346D04; - y = 64'hC1F01FFFFFFFFFFF; - z = 64'h322FFFFF80000001; - ans = 64'hF26163A2433AD5DD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3876949\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3878963\n"); - end - x = 64'hC033FFFFFFFFFFFD; - y = 64'hBFD0000000000001; - z = 64'hD590000300000000; - ans = 64'hD590000300000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3880977\n"); - end - x = 64'h402FC00000000001; - y = 64'hC92FFFFFFFFFFFFE; - z = 64'h400997A6065DBA19; - ans = 64'hC96FBFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3882991\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3885005\n"); - end - x = 64'hC8000000000007F8; - y = 64'hBFF0000000000001; - z = 64'h24E00000007FFFFE; - ans = 64'h48000000000007F9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3887019\n"); - end - x = 64'h3F50000001002000; - y = 64'h55C8A74A57511C8B; - z = 64'h7537B3CA2789A11F; - ans = 64'h7537B3CA2789A11F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3889033\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3891047\n"); - end - x = 64'h41F0010040000000; - y = 64'hC010000000000001; - z = 64'hAAE00001FFFFFFFA; - ans = 64'hC210010040000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3893061\n"); - end - x = 64'h4257359EB830CE5B; - y = 64'hBFD000400FFFFFFF; - z = 64'h7350000004400000; - ans = 64'h7350000004400000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3895075\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3897089\n"); - end - x = 64'h434000000000005F; - y = 64'hFFE0000000000000; - z = 64'hC3EFFDFF00000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3899103\n"); - end - x = 64'hC02FC0000000000F; - y = 64'hBCA398F05424163D; - z = 64'hC1E0000004800000; - ans = 64'hC1E0000004800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3901117\n"); - end - x = 64'hBCAFFFFFFFFFFFFE; - y = 64'hFFF0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3903131\n"); - end - x = 64'hC95FDFFFFFFFFDFF; - y = 64'h0000000000000000; - z = 64'hBAAFFF7FFFFFFFDF; - ans = 64'hBAAFFF7FFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3905145\n"); - end - x = 64'hE4C25C774D9F6F1B; - y = 64'h401FC00000FFFFFF; - z = 64'h3C3000000007EFFF; - ans = 64'hE4F237BE5F9713F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3907159\n"); - end - x = 64'hBFD0000000000000; - y = 64'h0010000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3909173\n"); - end - x = 64'hA35FFFFE000FFFFF; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h7FD00001FFEFFFFF; - ans = 64'h7FD00001FFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3911187\n"); - end - x = 64'h7FEC000000003FFF; - y = 64'hBB8FFFFFFF807FFE; - z = 64'h00060171223E7BB8; - ans = 64'hFB8BFFFFFF90AFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3913201\n"); - end - x = 64'hBFD0000000000000; - y = 64'h3FD0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3915215\n"); - end - x = 64'h43D0000100000001; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'hBD9FFFFFEFFFEFFF; - ans = 64'h43C0000100000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3917229\n"); - end - x = 64'hBDF0000000020002; - y = 64'h409FFFFFEFFF7FFF; - z = 64'hC020000000008000; - ans = 64'hC020000010007FF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3919243\n"); - end - x = 64'hBFD0000000000000; - y = 64'h3FF0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBFD0000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3921257\n"); - end - x = 64'hBFB0000000080080; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hFFD00200FFFFFFFF; - ans = 64'hFFD00200FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3923271\n"); - end - x = 64'hBFFFFFFFF0000004; - y = 64'h43F000000FF00000; - z = 64'hBFCFFFFFFEFFFF00; - ans = 64'hC400000007EFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3925285\n"); - end - x = 64'hBFD0000000000000; - y = 64'h4010000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3CB0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3927299\n"); - end - x = 64'hC1EFFFFE0000007E; - y = 64'h401FFFFFFFFFFFFF; - z = 64'hC3C73160DA37C1BE; - ans = 64'hC3C73160DE37C17E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3929313\n"); - end - x = 64'h7FD00000000002FE; - y = 64'h301FFFFFFFFFE3FE; - z = 64'h30E800003FFFFFFE; - ans = 64'h6FFFFFFFFFFFE9FA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3931327\n"); - end - x = 64'hBFD0000000000000; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC348000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3933341\n"); - end - x = 64'h41D00000000107FE; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h48201DFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3935355\n"); - end - x = 64'h801FFFFFFFFFDBFF; - y = 64'hC1FEFFFFFFFFF7FF; - z = 64'h47E3FFDFFFFFFFFF; - ans = 64'h47E3FFDFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3937369\n"); - end - x = 64'hBFD0000000000000; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3939383\n"); - end - x = 64'hC62020000000007F; - y = 64'h800FFFFFFFFFFFFF; - z = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3941397\n"); - end - x = 64'hB80FFFFFF7BFFFFF; - y = 64'hC7FFFFFF10000000; - z = 64'h43BFFFFBFFFFBFFF; - ans = 64'h43BFFFFBFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3943411\n"); - end - x = 64'hBFD0000000000000; - y = 64'h801FFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3945425\n"); - end - x = 64'h7FF00000000043FF; - y = 64'hBCA0000000000001; - z = 64'hC5D6CCE3D680D70E; - ans = 64'h7FF80000000043FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3947439\n"); - end - x = 64'hC01FF7FFFFFFFFFE; - y = 64'h43D0001FFFFFF000; - z = 64'h7FDFFFFFFBFFFEFF; - ans = 64'h7FDFFFFFFBFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3949453\n"); - end - x = 64'hBFD0000000000000; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFEC000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3951467\n"); - end - x = 64'hBCCB12E85BCA0CFE; - y = 64'hBFE0000000000001; - z = 64'h3F0FFFFF7FFFEFFF; - ans = 64'h3F0FFFFF8000C896; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3953481\n"); - end - x = 64'h802080000000FFFF; - y = 64'h5730000000000040; - z = 64'h7FF0000FFDFFFFFE; - ans = 64'h7FF8000FFDFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3955495\n"); - end - x = 64'hBFD0000000000000; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3957509\n"); - end - x = 64'h41900007FFFFFFFE; - y = 64'hC000000000000000; - z = 64'h41CE00007FFFFFFF; - ans = 64'h41C9FFFE80000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3959523\n"); - end - x = 64'hFFE020000001FFFF; - y = 64'hBFA6A9294AD2EAA6; - z = 64'h40200000000007E0; - ans = 64'h7F96D67B9D6B659F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3961537\n"); - end - x = 64'hBFD0000000000000; - y = 64'hC010000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3963551\n"); - end - x = 64'hC7E656DF82463376; - y = 64'hC340000000000000; - z = 64'hFFDF000800000000; - ans = 64'hFFDF000800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3965565\n"); - end - x = 64'h7ACDFFFFFFFFF800; - y = 64'h401FFFFFFE000800; - z = 64'h41ED906DDCD6B5DD; - ans = 64'h7AFDFFFFFE1FFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3967579\n"); - end - x = 64'hBFD0000000000000; - y = 64'hFFE0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FC0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3969593\n"); - end - x = 64'hC1D00000200001FF; - y = 64'hFFF0000000000000; - z = 64'hC01B8CDE8DE11ABC; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3971607\n"); - end - x = 64'h3FEFFFFFFFF80040; - y = 64'h43D00000017FFFFF; - z = 64'h40803FE000000000; - ans = 64'h43D00000017C0020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3973621\n"); - end - x = 64'hBFD0000000000001; - y = 64'h0000000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3975635\n"); - end - x = 64'h3D9FDFFFFFFFFE00; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hC0271DEF2549D40C; - ans = 64'hC0271DEF2549D40C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3977649\n"); - end - x = 64'hA480000FEFFFFFFF; - y = 64'hBFDF7FFBFFFFFFFF; - z = 64'h3FEBFFFF7FFFFFFE; - ans = 64'h3FEBFFFF7FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3979663\n"); - end - x = 64'hBFD0000000000001; - y = 64'h3CA0000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3981677\n"); - end - x = 64'h380FEFFFFFFF8000; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'hB7FF00000003FFFF; - ans = 64'hB7FF00000003FFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3983691\n"); - end - x = 64'hBFEF000FFFFFFFFF; - y = 64'h43ED53D0520EAC50; - z = 64'hC1F9B9E740692E8A; - ans = 64'hC3EC69407999D3C2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3985705\n"); - end - x = 64'hBFD0000000000001; - y = 64'h3FE0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3987719\n"); - end - x = 64'h3FFA65BB6D3D049F; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h0000003FFFFBFFFF; - ans = 64'h3FFA65BB6D3D049D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3989733\n"); - end - x = 64'hA07000000003FFC0; - y = 64'hBFCFFFFFE0010000; - z = 64'h37F04000000000FE; - ans = 64'h37F04000000000FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3991747\n"); - end - x = 64'hBFD0000000000001; - y = 64'h4000000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3993761\n"); - end - x = 64'h0020000000220000; - y = 64'h400FFFFFFFFFFFFF; - z = 64'h41A03FFBFFFFFFFF; - ans = 64'h41A03FFBFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3995775\n"); - end - x = 64'hBFC2576242253287; - y = 64'hB7F7DE6C30DD0BEF; - z = 64'hFFFFFFFFFFFF801F; - ans = 64'hFFFFFFFFFFFF801F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3997789\n"); - end - x = 64'hBFD0000000000001; - y = 64'h401FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hC008000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3999803\n"); - end - x = 64'h297DFFE000000000; - y = 64'h434FFFFFFFFFFFFF; - z = 64'hB9AFD73D50E72C73; - ans = 64'hB9AFD73D50E72C73; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4001817\n"); - end - x = 64'hC3C520C29AB52637; - y = 64'h4809CCE33765D79E; - z = 64'h4342000000000010; - ans = 64'hCBE108DEE66FCE60; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4003831\n"); - end - x = 64'hBFD0000000000001; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'hFFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4005845\n"); - end - x = 64'hBFBFFBFFFFFFFFEF; - y = 64'h7FF0000000000001; - z = 64'hFFDF7FFFFFFFFF7F; + x = 64'hBCA0000000000001; + y = 64'h43EFFFE7FFFFFFFF; + z = 64'h7FF0000000000001; ans = 64'h7FF8000000000001; rn = 1; rz = 0; @@ -93567,12 +285045,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4007859\n"); + $fwrite(fp,"3723295\n"); end - x = 64'h48017FFFFFFFFFFE; - y = 64'hC03D388E8E5584AC; - z = 64'h3FE0000000000010; - ans = 64'hC84FF5DBEBAD8918; + x = 64'hB7FFFFFFFFFFF8FF; + y = 64'hC3E4000000010000; + z = 64'h36EB61110674A849; + ans = 64'h3BF400000000FB9F; rn = 1; rz = 0; rm = 0; @@ -93614,12 +285092,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4009873\n"); + $fwrite(fp,"3723909\n"); end - x = 64'hBFD0000000000001; - y = 64'h800FFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + x = 64'hBCA0000000000001; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h0000000000000001; + ans = 64'hBCD0000000000000; rn = 1; rz = 0; rm = 0; @@ -93661,12 +285139,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4011887\n"); + $fwrite(fp,"3724523\n"); end - x = 64'h37FFE468EB15AC0A; - y = 64'h8010000000000001; - z = 64'hBF7FFFFFEFFFFFEE; - ans = 64'hBF7FFFFFEFFFFFEE; + x = 64'h400FFFFFE0000080; + y = 64'h4F6FFFFFF0000000; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'h4F8FFFFFD0000090; rn = 1; rz = 0; rm = 0; @@ -93708,763 +285186,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4013901\n"); + $fwrite(fp,"3725137\n"); end - x = 64'h402C000000000400; - y = 64'hCBB0000000000000; - z = 64'h7FDFFFFFFFFF7FEE; - ans = 64'h7FDFFFFFFFFF7FEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4015915\n"); - end - x = 64'hBFD0000000000001; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCA7FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4017929\n"); - end - x = 64'hDC4FFFFFFFFF001F; - y = 64'hBFD0000000000001; - z = 64'h54CFFFFFFFF7F7FE; - ans = 64'h5C2FFFFFFFFF0021; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4019943\n"); - end - x = 64'hB81FFFE00000001E; - y = 64'hC010000BFFFFFFFE; - z = 64'hC053557D26B59CB1; - ans = 64'hC053557D26B59CB1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4021957\n"); - end - x = 64'hBFD0000000000001; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF4000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4023971\n"); - end - x = 64'h480000001FFFFEFF; - y = 64'hBFF0000000000000; - z = 64'h40D86887350870A0; - ans = 64'hC80000001FFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4025985\n"); - end - x = 64'hFFF000407FFFFFFE; - y = 64'hC1DFFFFFFCFFFFFF; - z = 64'hC3E55EBCA5EEB15B; - ans = 64'hFFF800407FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4027999\n"); - end - x = 64'hBFD0000000000001; - y = 64'hC000000000000001; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4030013\n"); - end - x = 64'hC020100000000020; - y = 64'hC010000000000000; - z = 64'h48040000000000FF; - ans = 64'h48040000000000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4032027\n"); - end - x = 64'hBF5FFFFFFFE000FE; - y = 64'h335D310274E925EE; - z = 64'hBAC000000000000B; - ans = 64'hBAC000000000000B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4034041\n"); - end - x = 64'hBFD0000000000001; - y = 64'hC340000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4036055\n"); - end - x = 64'h380BFFFFFFFBFFFF; - y = 64'hFFE0000000000000; - z = 64'hC01555741BD41CAB; - ans = 64'hF7FBFFFFFFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4038069\n"); - end - x = 64'h3CD9B40821F9B3E4; - y = 64'h201F7FFEFFFFFFFF; - z = 64'h403FFFFFFC003FFE; - ans = 64'h403FFFFFFC003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4040083\n"); - end - x = 64'hBFD0000000000001; - y = 64'hFFF0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4042097\n"); - end - x = 64'hC03FFFFFC00001FF; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hBFDF000000000007; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4044111\n"); - end - x = 64'h410FFBFFBFFFFFFE; - y = 64'hB734156DEC8DD607; - z = 64'h43D009FFFFFFFFFF; - ans = 64'h43D009FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4046125\n"); - end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'h0010000000000000; - z = 64'hBFF0000000000001; + x = 64'hBCA0000000000001; + y = 64'h4340000000000000; + z = 64'hB9F00040007FFFFF; ans = 64'hBFF0000000000001; rn = 1; rz = 0; @@ -94507,12 +285233,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4048139\n"); + $fwrite(fp,"3725751\n"); end - x = 64'hC7FFFFFBFFC00000; - y = 64'h001FFFFFFFFFFFFE; - z = 64'hC7E0000000600000; - ans = 64'hC7E0000000600000; + x = 64'h480DFFEFFFFFFFFF; + y = 64'hBFCFFFEFFFFFF800; + z = 64'h3EA00000003FDFFF; + ans = 64'hC7EDFFE10007F87F; rn = 1; rz = 0; rm = 0; @@ -94554,12 +285280,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4050153\n"); + $fwrite(fp,"3726365\n"); end - x = 64'hC56FFFFFFEFF8000; - y = 64'hC34E2F7D229264D7; - z = 64'hD7EBFFFFFFFFEFFE; - ans = 64'hD7EBFFFFFFFFEFFE; + x = 64'hB800000001FFFDFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFEFFFFFFDF; rn = 1; rz = 0; rm = 0; @@ -94601,12 +285327,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4052167\n"); + $fwrite(fp,"3726979\n"); end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; + x = 64'hBCA0000000000001; + y = 64'h1B9FFFFFE000FFFF; + z = 64'h3FEFEFFFBFFFFFFE; + ans = 64'h3FEFEFFFBFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -94648,12 +285374,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4054181\n"); + $fwrite(fp,"3727593\n"); end - x = 64'hC1C2485C59A21EE6; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h43E0008000001000; - ans = 64'h43E0007FFFFDC6F4; + x = 64'hBF7FFFFFFBFEFFFE; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h403636BB565E6ADF; + ans = 64'hC2DFFFFFFBFEFA6E; rn = 1; rz = 0; rm = 0; @@ -94695,12 +285421,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4056195\n"); + $fwrite(fp,"3728207\n"); end - x = 64'h40117FFFFFFFFFFF; - y = 64'hC01CA9044303E0DB; - z = 64'h4C2000801FFFFFFF; - ans = 64'h4C2000801FFFFFFF; + x = 64'hBCA0000000000001; + y = 64'h3FB00001FFFC0000; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -94742,12 +285468,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4058209\n"); + $fwrite(fp,"3728821\n"); end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; + x = 64'hFFEF9571FF100553; + y = 64'hBE7FFFFE03FFFFFF; + z = 64'hBFBFFFFBFF000000; + ans = 64'h7E7F957009AB93A1; rn = 1; rz = 0; rm = 0; @@ -94789,12 +285515,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4060223\n"); + $fwrite(fp,"3729435\n"); end - x = 64'hCDFFFFFFFFFD8000; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h47E128374FD5C32C; - ans = 64'hCE0FFFFFFFFD7FFF; + x = 64'hBCA0000000000001; + y = 64'h7FE0000000000001; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -94836,58 +285562,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4062237\n"); + $fwrite(fp,"3730049\n"); end - x = 64'hC3D0001000000100; - y = 64'hB8100000207FFFFF; - z = 64'h400000000001003F; - ans = 64'h400000000001003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4064251\n"); - end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; + x = 64'hB81FFFFF8003FFFE; + y = 64'h400020001FFFFFFF; + z = 64'hBFFFFFFFFFFFFFFE; ans = 64'hBFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -94930,12 +285609,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4066265\n"); + $fwrite(fp,"3730663\n"); end - x = 64'hBCA007FFFFFFF7FE; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h4050000000000FFD; - ans = 64'h4050000000000FFD; + x = 64'hBCA0000000000001; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h9F80000003FFFFEE; + ans = 64'hFCA0000000000000; rn = 1; rz = 0; rm = 0; @@ -94977,12 +285656,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4068279\n"); + $fwrite(fp,"3731277\n"); end - x = 64'hBFB000000001FFFB; - y = 64'hC13E89BE71AC5F37; - z = 64'h43E0000000000203; - ans = 64'h43E0000000000240; + x = 64'hC15800000000003E; + y = 64'h4EE09FFFFFFFFFFF; + z = 64'hBFCFFFFFFFFFFF7F; + ans = 64'hD048F0000000003F; rn = 1; rz = 0; rm = 0; @@ -95024,1750 +285703,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4070293\n"); + $fwrite(fp,"3731891\n"); end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'hC33FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4072307\n"); - end - x = 64'hBCA2000000080000; - y = 64'h7FE0000000000001; - z = 64'h3FE0000080000003; - ans = 64'hFC92000000080001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4074321\n"); - end - x = 64'h3F9FFFFDFFFFFFBF; - y = 64'h43EFFC0000000000; - z = 64'h3EC6AF993615E8BC; - ans = 64'h439FFBFE003FFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4076335\n"); - end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4078349\n"); - end - x = 64'hC0A0001EFFFFFFFE; - y = 64'h8000000000000001; - z = 64'hC1C008000007FFFF; - ans = 64'hC1C008000007FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4080363\n"); - end - x = 64'h3CC56618EC6D04EC; - y = 64'hC02FFFFFFFF00000; - z = 64'h404003FFFFE00000; - ans = 64'h404003FFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4082377\n"); - end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4084391\n"); - end - x = 64'h4340000007BFFFFF; - y = 64'hBCA0000000000001; - z = 64'hFFDA1FF2E2AAA6DA; - ans = 64'hFFDA1FF2E2AAA6DA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4086405\n"); - end - x = 64'h41DFFF0003FFFFFF; - y = 64'hC8600007FFFFFFFD; - z = 64'hBFDF001FFFFFFFFF; - ans = 64'hCA4FFF10038001F9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4088419\n"); - end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3FD0000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4090433\n"); - end - x = 64'h3F3E007FFFFFFFFE; - y = 64'hBFE0000000000000; - z = 64'h3FF0000000001F7F; - ans = 64'h3FEFFE1FF8003EFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4092447\n"); - end - x = 64'h22E0000000003FBE; - y = 64'hBFF9249E6C798660; - z = 64'h3C8FFFFCFFFFFFFF; - ans = 64'h3C8FFFFCFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4094461\n"); - end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'hBFF0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFE0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4096475\n"); - end - x = 64'hC0BEFFDFFFFFFFFF; - y = 64'hC000000000000000; - z = 64'hBFFDFFFFFFFDFFFE; - ans = 64'h40CEFEF00000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4098489\n"); - end - x = 64'h8028007FFFFFFFFF; - y = 64'h73208000000003FE; - z = 64'hFFEFFBFFC0000000; - ans = 64'hFFEFFBFFC0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4100503\n"); - end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'hC010000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4102517\n"); - end - x = 64'hC070000000024000; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hC1E0000004003FFE; - ans = 64'hC1DFFFFE08007FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4104531\n"); - end - x = 64'h3F42000000000003; - y = 64'h37F22F335B65E2E0; - z = 64'h43C80000007FFFFF; - ans = 64'h43C80000007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4106545\n"); - end - x = 64'hBFDFFFFFFFFFFFFF; - y = 64'hFFE0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4108559\n"); - end - x = 64'h7FE040FFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hE2E00003FE000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4110573\n"); - end - x = 64'hBFEA81733546F034; - y = 64'h2626E518F36926A1; - z = 64'hC09FFF7FFFF7FFFE; - ans = 64'hC09FFF7FFFF7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4112587\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'h0000000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4114601\n"); - end - x = 64'hBF2FF00000000003; - y = 64'h000FFFFFFFFFFFFE; - z = 64'h8022000000FFFFFF; - ans = 64'h8022007FC0FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4116615\n"); - end - x = 64'h408FFFF0000007FF; - y = 64'h41D00000FFFFFFEF; - z = 64'hDC70402000000000; - ans = 64'hDC70402000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4118629\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'h3CA0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4120643\n"); - end - x = 64'hBE103FEFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h62FFFF7FFFBFFFFF; - ans = 64'h62FFFF7FFFBFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4122657\n"); - end - x = 64'h43C2010000000000; - y = 64'h41D2FD2FF3E9D4A6; - z = 64'hB800000002040000; - ans = 64'h45A55E05C5664DD8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4124671\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4126685\n"); - end - x = 64'h47E47B8A900D62AC; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hC01DB634A55C6312; - ans = 64'h47E47B8A900D62AB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4128699\n"); - end - x = 64'h41FC6E69D7DCEB33; - y = 64'hBFCFFFFFFF7FFFFE; - z = 64'h381FFFFFFFFFFFFF; - ans = 64'hC1DC6E69D76B318A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4130713\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4132727\n"); - end - x = 64'h3FC00000FFFC0000; - y = 64'h400FFFFFFFFFFFFF; - z = 64'h423D5A6FF0405C99; - ans = 64'h423D5A6FF040DC99; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4134741\n"); - end - x = 64'h47EFF000000001FE; - y = 64'h7FDFFFFFFFFFFEE0; - z = 64'h000FFFFDFDFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4136755\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4138769\n"); - end - x = 64'hBFDFFFFFFB000000; - y = 64'h4340000000000001; - z = 64'h42B0007FFFEFFFFF; - ans = 64'hC32FDFFEFB002002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4140783\n"); - end - x = 64'h3FD7F06D69FF62BE; - y = 64'h2B5E7140250D5798; - z = 64'h42E778A05FEDF936; - ans = 64'h42E778A05FEDF936; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4142797\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hFFDFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4144811\n"); - end - x = 64'h3240900000000000; + x = 64'hC770007FFFFFFFEF; y = 64'h7FF0000000000001; - z = 64'hC0600FF7FFFFFFFF; + z = 64'h001FFFFFFFFFFFFE; ans = 64'h7FF8000000000001; rn = 1; rz = 0; @@ -96810,12 +285750,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4146825\n"); + $fwrite(fp,"3732505\n"); end - x = 64'h43CFFFFFFFEFEFFF; - y = 64'hB9BFFFFEFFFFF7FF; - z = 64'h3FD066C1AC02AAC5; - ans = 64'h3FD066C1AC00AAC5; + x = 64'hBCA0000000000001; + y = 64'h7FDA7310ABEAE84F; + z = 64'h48A73ACD31EA4F8E; + ans = 64'hFC8A7310ABEAE851; rn = 1; rz = 0; rm = 0; @@ -96857,1562 +285797,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4148839\n"); + $fwrite(fp,"3733119\n"); end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4150853\n"); - end - x = 64'h001FFFFFC07FFFFF; - y = 64'h8010000000000000; - z = 64'h02BE69A571E64868; - ans = 64'h02BE69A571E64868; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4152867\n"); - end - x = 64'hC801D6762B8F708B; - y = 64'hBFF000008000001F; - z = 64'hB26FF8000000FFFE; - ans = 64'h4801D676BA43220A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4154881\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'hBCA0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4156895\n"); - end - x = 64'h43CF6221B792A495; - y = 64'hBFD0000000000000; - z = 64'hB79000FFFFFFFFFF; - ans = 64'hC3AF6221B792A495; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4158909\n"); - end - x = 64'h434FFFFFFEFFE000; - y = 64'h402ECBE6EE1B4687; - z = 64'h3FC46C50F0C047D2; - ans = 64'h438ECBE6ED24C884; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4160923\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'hBFE0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FCFFFFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4162937\n"); - end - x = 64'hC02DFFFFFFFFFEFE; - y = 64'hBFF0000000000000; - z = 64'h49120007FFFFFFFE; - ans = 64'h49120007FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4164951\n"); - end - x = 64'h381FFFFFFFDFFFFF; - y = 64'hBFE020000000003F; - z = 64'hC01FFFFFFFFE0100; - ans = 64'hC01FFFFFFFFE0100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4166965\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC000000000000001; - z = 64'h3FF0000000000001; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4168979\n"); - end - x = 64'h801FFEFFFFFFEFFF; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'h3FBFFFFFFFFEFF7E; - ans = 64'h3FBFFFFFFFFEFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4170993\n"); - end - x = 64'hC0FFDFFFFFFE0000; - y = 64'h3F9FFFFF80000001; - z = 64'hC34FFFFFFF800000; - ans = 64'hC34FFFFFFF8007F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4173007\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC340000000000000; - z = 64'hC340000000000000; - ans = 64'hC330000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4175021\n"); - end - x = 64'hC02CF9D37F232E60; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h000FFFFFF8000040; - ans = 64'h438CF9D37F232E5E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4177035\n"); - end - x = 64'h0DE003FFF8000000; - y = 64'h41FBFFFFFFFFFFDE; - z = 64'h3E4D71A95D335306; - ans = 64'h3E4D71A95D335306; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4179049\n"); - end - x = 64'hBFDFFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4181063\n"); - end - x = 64'h41FFFFFC3FFFFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hC01A0C790AA8541A; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4183077\n"); - end - x = 64'hC080000000043FFF; - y = 64'h3E80000004007FFE; - z = 64'hC1C9224041A80188; - ans = 64'hC1C9224041A80388; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4185091\n"); - end - x = 64'hBFE0000000000000; - y = 64'h0010000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4187105\n"); - end - x = 64'h403FFFFFBDFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - z = 64'hDDFFFFFFFFFFFCFF; - ans = 64'hDDFFFFFFFFFFFCFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4189119\n"); - end - x = 64'hC3C0030000000000; - y = 64'h3FC0010000000004; - z = 64'hC0208000000001FF; - ans = 64'hC390040030000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4191133\n"); - end - x = 64'hBFE0000000000000; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4193147\n"); - end - x = 64'hB07D269A66E4F2B6; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'hBF500020000007FE; - ans = 64'hBF500020000007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4195161\n"); - end - x = 64'h43CFFFFFFFFFFE01; - y = 64'hC34F7FFFBFFFFFFF; - z = 64'h43C0000000F7FFFF; - ans = 64'hC72F7FFFBFFFFE08; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4197175\n"); - end - x = 64'hBFE0000000000000; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4199189\n"); - end - x = 64'h801008007FFFFFFE; - y = 64'h3FF0000000000001; - z = 64'h447007F7FFFFFFFE; - ans = 64'h447007F7FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4201203\n"); - end - x = 64'hBCA003FFFFFF0000; - y = 64'h400AC4372520559F; - z = 64'h3FCBD9E12AC2C108; - ans = 64'h3FCBD9E12AC2C0FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4203217\n"); - end - x = 64'hBFE0000000000000; - y = 64'h400FFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4205231\n"); - end - x = 64'hC25FFEFFFFFEFFFF; - y = 64'h4010000000000001; - z = 64'h38067F748D1E9A72; - ans = 64'hC27FFEFFFFFF0001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4207245\n"); - end - x = 64'h4BB000040000003E; - y = 64'h318FFFFFFFFFF7FF; - z = 64'hBFE0000000000017; - ans = 64'hBFDFFFFFFFFFF02E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4209259\n"); - end - x = 64'hBFE0000000000000; - y = 64'h434FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC33FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4211273\n"); - end - x = 64'hC99FFF7800000000; - y = 64'h7FE0000000000001; - z = 64'hB7EFFF8000800000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4213287\n"); - end - x = 64'h47F7C717A1E0D326; - y = 64'h001FFFFFF00FFFFF; - z = 64'h00001FFFFFFFFFBE; - ans = 64'h0827C71796092AE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4215301\n"); - end - x = 64'hBFE0000000000000; + x = 64'hC0D60CA21F4AD012; y = 64'h7FFFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; + z = 64'hBFD4DCE5D90DAA50; ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -98455,7155 +285844,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4217315\n"); + $fwrite(fp,"3733733\n"); end - x = 64'hF57FFFFFFFFFFFFF; - y = 64'h8000000000000000; - z = 64'hC97002FFFFFFFFFE; - ans = 64'hC97002FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4219329\n"); - end - x = 64'hC1DFFFFDFFFFFEFF; - y = 64'h0773FFFF7FFFFFFE; - z = 64'h38100000001FF7FF; - ans = 64'h38100000001FF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4221343\n"); - end - x = 64'hBFE0000000000000; - y = 64'h8010000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4223357\n"); - end - x = 64'hC3410000000003FF; - y = 64'hBCA0000000000000; - z = 64'h80100000FFFFF000; - ans = 64'h3FF10000000003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4225371\n"); - end - x = 64'hC03FFEFFFFFFFDFF; - y = 64'h40BC282748CFC06D; - z = 64'hBF2FFFFEFDFFFFFE; - ans = 64'hC10C274608157828; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4227385\n"); - end - x = 64'hBFE0000000000000; - y = 64'hBFD0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4229399\n"); - end - x = 64'hC3C1FFFFFFFFFFEE; - y = 64'hBFE0000000000000; - z = 64'h56200000000203FE; - ans = 64'h56200000000203FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4231413\n"); - end - x = 64'h489FEFFFFFFFFF00; - y = 64'h22FFF007FFFFFFFF; - z = 64'h43F1293689290D1A; - ans = 64'h43F1293689290D1A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4233427\n"); - end - x = 64'hBFE0000000000000; - y = 64'hBFF0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3FE0000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4235441\n"); - end - x = 64'hC3D0000007FFFEFF; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'h4343523E456566FF; - ans = 64'h43E004D497915858; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4237455\n"); - end - x = 64'h41DFFFE003FFFFFE; - y = 64'h3FF00003FFFFFF7E; - z = 64'h80067F5CA0F4F00E; - ans = 64'h41DFFFE803F7FFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4239469\n"); - end - x = 64'hBFE0000000000000; - y = 64'hC010000000000000; - z = 64'hBFF0000000000001; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4241483\n"); - end - x = 64'hB7FEF51E4B4DCBEF; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFAFFFF; - ans = 64'hBCAFFFFFFFFAFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4243497\n"); - end - x = 64'h47E30F7EC43AD2A9; - y = 64'h4020203FFFFFFFFE; - z = 64'h3FCF7FFFFFBFFFFF; - ans = 64'h481335E9FFBE5937; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4245511\n"); - end - x = 64'hBFE0000000000000; - y = 64'hFFE0000000000000; - z = 64'h4340000000000000; - ans = 64'h7FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4247525\n"); - end - x = 64'hB7EFEFFFFFFFFFF7; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hFFDD4FE4B235EA5D; - ans = 64'hFFDD4FE4B235EA5D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4249539\n"); - end - x = 64'hBFDFFFFFFFFFF81F; - y = 64'hC020007F80000000; - z = 64'h43EAB3830C35EB3F; - ans = 64'h43EAB3830C35EB3F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4251553\n"); - end - x = 64'hBFE0000000000000; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4253567\n"); - end - x = 64'hBFD23FFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - z = 64'h401FFFFDFFFFFFFF; - ans = 64'h401FFFFDFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4255581\n"); - end - x = 64'h480FFFFFFFFFE003; - y = 64'h3FCE71E027D1E6CF; - z = 64'h3D32000000001000; - ans = 64'h47EE71E027D1C860; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4257595\n"); - end - x = 64'hBFE0000000000001; - y = 64'h001FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4259609\n"); - end - x = 64'h2580002000000100; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h380FFFFFFF7FDFFF; - ans = 64'h380FFFFFFF7FDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4261623\n"); - end - x = 64'h3CA000000007F000; - y = 64'h43CDFFFBFFFFFFFE; - z = 64'hC80FFFFFEFFFFFE0; - ans = 64'hC80FFFFFEFFFFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4263637\n"); - end - x = 64'hBFE0000000000001; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FE8000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4265651\n"); - end - x = 64'h000080000000007F; - y = 64'h3FE0000000000001; - z = 64'h3FBFFFFFFC00001E; - ans = 64'h3FBFFFFFFC00001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4267665\n"); - end - x = 64'h3FFFFFFC00003FFF; - y = 64'hC1DD368E07D8CF94; - z = 64'h381FFFFFF0000008; - ans = 64'hC1ED368A61074905; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4269679\n"); - end - x = 64'hBFE0000000000001; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4271693\n"); - end - x = 64'h4070400000000100; - y = 64'h4000000000000001; - z = 64'h40300000001FF800; - ans = 64'h4080C000000100C1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4273707\n"); - end - x = 64'hB7E0000400000000; - y = 64'hC805546FB3FF2B69; - z = 64'h2F2007FFFFFFFC00; - ans = 64'h3FF55475091B1869; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4275721\n"); - end - x = 64'hBFE0000000000001; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4277735\n"); - end - x = 64'h40D00000000FFFEF; - y = 64'h4340000000000001; - z = 64'h401FFFFD7FFFFFFF; - ans = 64'h44200000000FFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4279749\n"); - end - x = 64'h556FFFE000000400; - y = 64'hBF900800000003FF; - z = 64'hBD3FEFFEFFFFFFFF; - ans = 64'hD51007EFF8000600; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4281763\n"); - end - x = 64'hBFE0000000000001; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4283777\n"); - end - x = 64'h4006E2164F181ABB; - y = 64'h7FF0000000000000; - z = 64'h37F0800000000008; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4285791\n"); - end - x = 64'h398FFFFFFFFBFFC0; - y = 64'hC0A783C6E834743B; - z = 64'h381FFFFFFFFEF000; - ans = 64'hBA4783C6E82D8393; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4287805\n"); - end - x = 64'hBFE0000000000001; - y = 64'h8000000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4289819\n"); - end - x = 64'h37FEFFFFFF800000; - y = 64'h8010000000000000; - z = 64'hBFFFF80007FFFFFE; - ans = 64'hBFFFF80007FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4291833\n"); - end - x = 64'h415FFFE0000001FF; - y = 64'hC1CFFFF77FFFFFFF; - z = 64'h47F0200000000FFE; - ans = 64'h47F0200000000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4293847\n"); - end - x = 64'hBFE0000000000001; - y = 64'hBCA0000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4295861\n"); - end - x = 64'h3DAFFFFFEFFE0000; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h9E4FFF0000FFFFFF; - ans = 64'hBA6FFFFFEFFDFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4297875\n"); - end - x = 64'hFC840001FFFFFFFF; - y = 64'hBFF003FFFFFFFFFE; - z = 64'hB7F000000004000F; - ans = 64'h7C840502007FFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4299889\n"); - end - x = 64'hBFE0000000000001; - y = 64'hBFE0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4301903\n"); - end - x = 64'h3FD007DFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hBFC5181D7BDE39EF; - ans = 64'hBFDA93EEBDEF1CF4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4303917\n"); - end - x = 64'h303018350289038C; - y = 64'hE68FFFFFFFFFDFEF; - z = 64'hB80FC00020000000; - ans = 64'hD6D018350288F36B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4305931\n"); - end - x = 64'hBFE0000000000001; - y = 64'hC000000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4307945\n"); - end - x = 64'hBF5FE0000000001F; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hC34FEFFC00000000; - ans = 64'hC34FEFFC00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4309959\n"); - end - x = 64'h3FE123613DB144E9; - y = 64'h42E07FFFFF7FFFFF; - z = 64'h7FD00FFFFFF7FFFF; - ans = 64'h7FD00FFFFFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4311973\n"); - end - x = 64'hBFE0000000000001; - y = 64'hC340000000000000; - z = 64'h3FF0000000000001; - ans = 64'h4330000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4313987\n"); - end - x = 64'h3CA0000007FC0000; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'h42D20F3B307165CC; - ans = 64'h42D20F3B3071654C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4316001\n"); - end - x = 64'hC1EFFFE00000003E; - y = 64'h43D0001FFFFC0000; - z = 64'hFFEC761D088A43AC; - ans = 64'hFFEC761D088A43AC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4318015\n"); - end - x = 64'hBFE0000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4320029\n"); - end - x = 64'hC0B2F9F4C13E948F; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h7FFD22CA98E89510; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4322043\n"); - end - x = 64'h40304125AC71B55E; - y = 64'h41CFFFFFFBFFFFEE; - z = 64'h47FFFFFFFFFFFFBF; - ans = 64'h47FFFFFFFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4324057\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4326071\n"); - end - x = 64'hC48010007FFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h7FDFFFFFFFFFC03F; - ans = 64'h7FDFFFFFFFFFC03F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4328085\n"); - end - x = 64'h4120000010003FFF; - y = 64'hBFB0000000028000; - z = 64'h3FF0000001F7FFFF; - ans = 64'hC0DFFFC02005781E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4330099\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h396FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4332113\n"); - end - x = 64'h37FFFFFFFFFFFEFD; - y = 64'h3FD0000000000001; - z = 64'h40EE00000007FFFE; - ans = 64'h40EE00000007FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4334127\n"); - end - x = 64'h41F0000007FFDFFF; - y = 64'hC80FFC0000FFFFFE; - z = 64'hB81046EFCDE22968; - ans = 64'hCA0FFC0010FDC005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4336141\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4338155\n"); - end - x = 64'h3CCFFFFFDFFFFFBF; - y = 64'h3FF0000000000001; - z = 64'h00000000FFFFFFFC; - ans = 64'h3CCFFFFFDFFFFFC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4340169\n"); - end - x = 64'h3C0FFFFFF7FBFFFF; - y = 64'h380FF001FFFFFFFE; - z = 64'h7FE0080003FFFFFF; - ans = 64'h7FE0080003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4342183\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4344197\n"); - end - x = 64'hC1FFFFFFFFFFEEFE; - y = 64'h4010000000000000; - z = 64'h3DCD0691292BF78D; - ans = 64'hC21FFFFFFFFFEEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4346211\n"); - end - x = 64'h3FB101FFFFFFFFFE; - y = 64'hB7FFFFFFBEFFFFFF; - z = 64'h4040000008001FFF; - ans = 64'h4040000008001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4348225\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'h4340000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4350239\n"); - end - x = 64'h3FE0EFFFFFFFFFFE; - y = 64'h7FE0000000000000; - z = 64'hC0F00000001000FF; - ans = 64'h7FD0EFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4352253\n"); - end - x = 64'h433FEFF7FFFFFFFF; - y = 64'h43EB97EE9E7AD837; - z = 64'h802FC08000000000; - ans = 64'h473B8A1BC12FF32B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4354267\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'h7FF0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4356281\n"); - end - x = 64'hBFEFFFFF7FFFFFFA; - y = 64'h8000000000000000; - z = 64'hC9D51348049C8AC5; - ans = 64'hC9D51348049C8AC5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4358295\n"); - end - x = 64'hCF7FFFFFFC07FFFE; - y = 64'h4DA00400FFFFFFFE; - z = 64'hBA5FFBFFFFFFFFFF; - ans = 64'hDD300400FE0380DD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4360309\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'h8010000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4362323\n"); - end - x = 64'hBFF0000000010040; - y = 64'h801FFFFFFFFFFFFE; - z = 64'hBCFDCB9919AF4A76; - ans = 64'hBCFDCB9919AF4A76; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4364337\n"); - end - x = 64'hC02000003FFFFFEF; - y = 64'hB8100001FFFFFFEE; - z = 64'hBFFB3C96CC3112C5; - ans = 64'hBFFB3C96CC3112C5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4366351\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBFD0000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4368365\n"); - end - x = 64'hBCA0000000100001; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hCDD09F02D825FADA; - ans = 64'hCDD09F02D825FADA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4370379\n"); - end - x = 64'h860004000000003E; - y = 64'h402FFFFFFFFF7FFF; - z = 64'h37F0B37850D0BDF3; - ans = 64'h37F0B37850D0BDF3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4372393\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBFF0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4374407\n"); - end - x = 64'hC3C0003FFFFFFFDE; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'h3EA0FFFFDFFFFFFF; - ans = 64'h43D0003FFFFFFFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4376421\n"); - end - x = 64'hBFB00FFFFEFFFFFE; - y = 64'h7FDFFFFFFFFFBFFF; - z = 64'h2BFBE93A66C88A23; - ans = 64'hFFA00FFFFEFFDFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4378435\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC010000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4380449\n"); - end - x = 64'hC14FFFFFFFFF7DFF; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'hFFEFFFFFFBFFFE00; - ans = 64'hFFEFFFFFFBFFFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4382463\n"); - end - x = 64'h52CFFFFFFFBFFF7F; - y = 64'h30BFFFFBFFFE0000; - z = 64'hBE5FFFF7FFFFFBFE; - ans = 64'h439FFFFBFFBDFF87; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4384477\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'h434FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4386491\n"); - end - x = 64'h41EFFFFFDFFFFF7F; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hBFBFFBFFFFFDFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4388505\n"); - end - x = 64'hC1E1FFFFFFFFFFFE; - y = 64'h43C400000001FFFF; - z = 64'hBFC1007FFFFFFFFF; - ans = 64'hC5B6800000023FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4390519\n"); - end - x = 64'hBFEFFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4392533\n"); - end - x = 64'h3F0C000000000000; - y = 64'h0000000000000001; - z = 64'h26D0000040000003; - ans = 64'h26D0000040000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4394547\n"); - end - x = 64'h45DFFFFFEEFFFFFF; - y = 64'h0DBFFFF900000000; - z = 64'hFFF0000000001FEE; - ans = 64'hFFF8000000001FEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4396561\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4398575\n"); - end - x = 64'h37F0000FFFFFF800; - y = 64'h3CA0000000000001; - z = 64'h4000100000007FFF; - ans = 64'h4000100000007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4400589\n"); - end - x = 64'h8021B1B7A213FD62; - y = 64'h9BEEFFFFFEFFFFFF; - z = 64'h20DF81119141D6F5; - ans = 64'h20DF81119141D6F5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4402603\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4404617\n"); - end - x = 64'hC02FFFFFC1000000; - y = 64'h3FE0000000000001; - z = 64'h0E1FFFFFFFFFFFDF; - ans = 64'hC01FFFFFC1000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4406631\n"); - end - x = 64'hBFE4E0F4ED990912; - y = 64'hFFE0FFFDFFFFFFFE; - z = 64'h395AD82B659403EC; - ans = 64'h7FD62F01A053FBED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4408645\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'hBFEFFFFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4410659\n"); - end - x = 64'hC1FFFFFFFFFFFFDF; - y = 64'h4000000000000000; - z = 64'h402DFFFEFFFFFFFF; - ans = 64'hC20FFFFFFF87FFE3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4412673\n"); - end - x = 64'h7F3A96D500067E61; - y = 64'hBFBFFFFBDFFFFFFF; - z = 64'hC030080000000007; - ans = 64'hFF0A96D19295095F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4414687\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'h4010000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4416701\n"); - end - x = 64'hA4F00007FFFFF7FE; - y = 64'h4340000000000000; - z = 64'h8A6FC00000003FFF; - ans = 64'hA8400007FFFFF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4418715\n"); - end - x = 64'h40234CA759EBC6DF; - y = 64'h3FD0007FFFFFFFFB; - z = 64'hC20B30390456082E; - ans = 64'hC20B30390442BAEC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4420729\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'h7FE0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4422743\n"); - end - x = 64'h3C7BDD677D2DE8B2; - y = 64'h7FF0000000000000; - z = 64'hBFDFFBFFF8000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4424757\n"); - end - x = 64'h3FBFFFFFFFFFF7BE; - y = 64'hC031F40CE9ABE276; - z = 64'hB7FFC10000000000; - ans = 64'hC001F40CE9ABDDD4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4426771\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'h8000000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4428785\n"); - end - x = 64'hC7F000FDFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h31225368A2EAE69C; - ans = 64'h31225368A2EAE69C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4430799\n"); - end - x = 64'hA3A0000000001000; - y = 64'hC7F0000000100040; - z = 64'h43B12238326B72C7; - ans = 64'h43B12238326B72C7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4432813\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBCA0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4434827\n"); - end - x = 64'h47E0000000000FFE; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h54764316901F286C; - ans = 64'h54764316901F286C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4436841\n"); - end - x = 64'hC3FEA8421E763A73; - y = 64'hC02FFFFF88000000; - z = 64'h403FFFF8FFFFFFFF; - ans = 64'h443EA841AB7F4281; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4438855\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBFE0000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4440869\n"); - end - x = 64'h4032FFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'h3FEFFFBFFFFFBFFF; - ans = 64'hC0320002000001FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4442883\n"); - end - x = 64'h380FFFFDFEFFFFFE; - y = 64'hC47F7FFFFFFFFFF7; - z = 64'hB7FFFFFF80003FFF; - ans = 64'hBC9F7FFE0703FFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4444897\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4446911\n"); - end - x = 64'h3E7491C102F637FB; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h401FFFFE000007FF; - ans = 64'h401FFFFDEB6E46FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4448925\n"); - end - x = 64'hC17614B22E982158; - y = 64'hC3C001FFFFFFDFFE; - z = 64'hBEB0001FFFFFFEFF; - ans = 64'h45461774C4DDC830; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4450939\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4452953\n"); - end - x = 64'h3F6F814B1821DEBD; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hB80FFEFFFFBFFFFF; - ans = 64'hC2CF814B1821DEBC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4454967\n"); - end - x = 64'h9B0007FFEFFFFFFE; - y = 64'h000E000001FFFFFE; - z = 64'h3810000000FF8000; - ans = 64'h3810000000FF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4456981\n"); - end - x = 64'hBFEFFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h7FEFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4458995\n"); - end - x = 64'hDD53FDFFFFFFFFFF; - y = 64'hFFF0000000000001; - z = 64'h41F0003FF0000000; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4461009\n"); - end - x = 64'hC01FFFFFFFC0000F; - y = 64'h4800000000FF7FFE; - z = 64'h380FFFFFFFFE00FE; - ans = 64'hC830000000DF8005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4463023\n"); - end - x = 64'hBFF0000000000000; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4465037\n"); - end - x = 64'h023FFFF000FFFFFE; - y = 64'h0010000000000001; - z = 64'h480FFFFFFFFFFF88; - ans = 64'h480FFFFFFFFFFF88; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4467051\n"); - end - x = 64'hC7F0000000007EFF; - y = 64'hBA5001F800000000; - z = 64'h41CFFFFFFFFFFFEB; - ans = 64'h425011F800007F0F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4469065\n"); - end - x = 64'hBFF0000000000000; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4471079\n"); - end - x = 64'h3FD0040000000FFF; - y = 64'h3FD0000000000001; - z = 64'h381FFFFFFFFFFFAF; - ans = 64'h3FB0040000001000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4473093\n"); - end - x = 64'hC1D0000020080000; - y = 64'h4072EBBC8A7E099C; - z = 64'hB800FDFFFFFFFFFE; - ans = 64'hC252EBBCB05EF88F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4475107\n"); - end - x = 64'hBFF0000000000000; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4477121\n"); - end - x = 64'hC7F00003FFFBFFFE; - y = 64'h3FF0000000000000; - z = 64'h4C00000000000004; - ans = 64'h4C00000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4479135\n"); - end - x = 64'h41FFFFFFFFFFF020; - y = 64'hB81F807FFFFFFFFE; - z = 64'h401FFFFFFDFFFC00; - ans = 64'h401FFFFFFDFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4481149\n"); - end - x = 64'hBFF0000000000000; - y = 64'h4000000000000001; - z = 64'hBFF0000000000001; - ans = 64'hC008000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4483163\n"); - end - x = 64'h3FE0800007FFFFFF; - y = 64'h4010000000000000; - z = 64'h352000003FFFFFFC; - ans = 64'h4000800007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4485177\n"); - end - x = 64'h40057F9AD8C03509; - y = 64'hBFCFFFFF00007FFF; - z = 64'h3FEFC0FFFFFFFFFF; - ans = 64'h3FD482CBA678977D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4487191\n"); - end - x = 64'hBFF0000000000000; - y = 64'h4340000000000001; - z = 64'h4340000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4489205\n"); - end - x = 64'h87DFFFFFFFF81FFF; - y = 64'h434FFFFFFFFFFFFE; - z = 64'h3B57637B7C305FA0; - ans = 64'h3B57637B7C305FA0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4491219\n"); - end - x = 64'h37E00000077FFFFF; - y = 64'hBCACCF6DD7D97B4E; - z = 64'hC130009FFFFFFFFF; - ans = 64'hC130009FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4493233\n"); - end - x = 64'hBFF0000000000000; - y = 64'h7FF0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4495247\n"); - end - x = 64'h3E0FFFFC000003FF; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hBF1FFFFF80000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4497261\n"); - end - x = 64'hC3E29C257CEEF008; - y = 64'h3FCFFFFFFEFF7FFF; - z = 64'h3FC81A16A0AEB127; - ans = 64'hC3C29C257C59C46B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4499275\n"); - end - x = 64'hBFF0000000000000; - y = 64'h8010000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4501289\n"); - end - x = 64'hC34FFFFF000FFFFF; - y = 64'h801FFFFFFFFFFFFE; - z = 64'h37F0000000403FFE; - ans = 64'h37F0000000403FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4503303\n"); - end - x = 64'hC1B000000FFFBFFF; - y = 64'hBCA01C44AB43B464; - z = 64'h456F2E37330BD0CF; - ans = 64'h456F2E37330BD0CF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4505317\n"); - end - x = 64'hBFF0000000000000; - y = 64'hBFD0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF4000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4507331\n"); - end - x = 64'h3FB0000001DFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'h40FFFFFFFFC10000; - ans = 64'h40FFFFFF7FC0FFF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4509345\n"); - end - x = 64'hC00689BAC8335603; - y = 64'h4B700203FFFFFFFF; - z = 64'h47F000000000DFFE; - ans = 64'hCB868C91A1FB0E79; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4511359\n"); - end - x = 64'hBFF0000000000000; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4513373\n"); - end - x = 64'hBCA3B1086BF83C68; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'hBFFFFFF000FFFFFF; - ans = 64'hBFFFFFF000FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4515387\n"); - end - x = 64'h40FFFFFBFC000000; - y = 64'h43EFFFEFFFFFFEFF; - z = 64'hC3E0000088000000; - ans = 64'h44FFFFE3FC01BCFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4517401\n"); - end - x = 64'hBFF0000000000000; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4519415\n"); - end - x = 64'hFFD91A9D576F11A5; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h25F8F363F18CAEF3; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4521429\n"); - end - x = 64'h3798007FFFFFFFFF; - y = 64'hC3D0000000008080; - z = 64'h0000200020000000; - ans = 64'hBB7800800000C0C3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4523443\n"); - end - x = 64'hBFF0000000000000; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; + x = 64'hBCA0000000000001; + y = 64'h401FF7FFFFFFFDFF; + z = 64'h434FFFFFFFFFFFFE; ans = 64'h434FFFFFFFFFFFFE; rn = 1; rz = 0; @@ -105646,12 +285891,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4525457\n"); + $fwrite(fp,"3734347\n"); end - x = 64'h7FD0000000001000; - y = 64'hFFE0000000000001; - z = 64'hC06E4CD1A7F9E48F; - ans = 64'hFFF0000000000000; + x = 64'h477FFFF7FFFFBFFF; + y = 64'h41D00200000FFFFF; + z = 64'hBFBFFFFFFFFFFFD8; + ans = 64'h496001FBFF8FDFF6; rn = 1; rz = 0; rm = 0; @@ -105693,4006 +285938,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4527471\n"); + $fwrite(fp,"3734961\n"); end - x = 64'h3FB7FFFFFFFFFFF6; - y = 64'h40200003FFFFFC00; - z = 64'hBF9000000FFFFFBE; - ans = 64'h3FE78005FF7FF9F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4529485\n"); - end - x = 64'hBFF0000000000000; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4531499\n"); - end - x = 64'hC34FDFFFFFFBFFFF; - y = 64'h0000000000000001; - z = 64'h00000007FBFFFFFF; - ans = 64'h802FDFFC01FC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4533513\n"); - end - x = 64'hBAA0004000000003; - y = 64'h3FCFEFFFFFFFFDFE; - z = 64'h41DFEFEFFFFFFFFE; - ans = 64'h41DFEFEFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4535527\n"); - end - x = 64'hBFF0000000000001; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4537541\n"); - end - x = 64'h000FFFFDFFFFFBFE; - y = 64'h3CA0000000000000; - z = 64'hD0D0000004000000; - ans = 64'hD0D0000004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4539555\n"); - end - x = 64'hFFD00FFFFFFFFFFC; - y = 64'hC0DA4296FEAC7D13; - z = 64'h3FD0200000000003; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4541569\n"); - end - x = 64'hBFF0000000000001; - y = 64'h3FD0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4543583\n"); - end - x = 64'hC3FFFFFFFFFFFB80; - y = 64'h3FE0000000000000; - z = 64'hC3EFFFFFFFFF9FFE; - ans = 64'hC3FFFFFFFFFFCDBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4545597\n"); - end - x = 64'h43D35995D8DCF194; - y = 64'h320FFFFFFE000006; - z = 64'h404FDFFFFFFFFEFE; - ans = 64'h404FDFFFFFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4547611\n"); - end - x = 64'hBFF0000000000001; - y = 64'h3FF0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBFF0000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4549625\n"); - end - x = 64'h2FAFFFFBFBFFFFFF; - y = 64'h4000000000000000; - z = 64'hC0300000000EFFFE; - ans = 64'hC0300000000EFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4551639\n"); - end - x = 64'hEADFF7035B159F4C; - y = 64'hC00BFFFFFFFFBFFF; - z = 64'hCBF00020000003FF; - ans = 64'h6AFBF822EFB2AB73; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4553653\n"); - end - x = 64'hBFF0000000000001; - y = 64'h4010000000000001; - z = 64'h3FF0000000000001; - ans = 64'hC008000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4555667\n"); - end - x = 64'hBCA926B08C93F8CE; - y = 64'h401FFFFFFFFFFFFE; - z = 64'hC01FFF7FFF7FFFFF; - ans = 64'hC01FFF7FFF800001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4557681\n"); - end - x = 64'hC02001FFFDFFFFFF; - y = 64'h3FE00000800FFFFF; - z = 64'hC02F5B9B276E56D7; - ans = 64'hC033AE4DB33F2BE7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4559695\n"); - end - x = 64'hBFF0000000000001; - y = 64'h7FE0000000000000; - z = 64'hC340000000000000; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4561709\n"); - end - x = 64'hCC3FFFE00001FFFF; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'h41FFFFFFFBFFDFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4563723\n"); - end - x = 64'h37EE7CD50F3001A6; - y = 64'hC02FFFFFFFFC000F; - z = 64'h8020000040000010; - ans = 64'hB82E7CD50F2C321A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4565737\n"); - end - x = 64'hBFF0000000000001; + x = 64'hBCA0000000000001; y = 64'h8000000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4567751\n"); - end - x = 64'hC02002FFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hA2400000001FFBFF; - ans = 64'hA2400000001FFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4569765\n"); - end - x = 64'h410FFFFFFFC07FFF; - y = 64'h3800000000009FFE; - z = 64'hC03FFFFB00000000; - ans = 64'hC03FFFFB00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4571779\n"); - end - x = 64'hBFF0000000000001; - y = 64'hBCA0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CB8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4573793\n"); - end - x = 64'hBFF8E19F4056F6DE; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'h8015EF2373E6512B; - ans = 64'h3CB8E19F4056F6DD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4575807\n"); - end - x = 64'hC3C86555AE0CF8FE; - y = 64'hBCA59E810275F37D; - z = 64'h3D7152CDF414B4CE; - ans = 64'h40807B56EBA58A9E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4577821\n"); - end - x = 64'hBFF0000000000001; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFE0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4579835\n"); - end - x = 64'h7FD00080000FFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hC8D001FFFFFFDFFE; - ans = 64'hFFD00080000FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4581849\n"); - end - x = 64'hB7FFFFFFFFFF9FFF; - y = 64'h3FC3853BC130E493; - z = 64'hB1500007FFFFFDFE; - ans = 64'hB7D3853BC130AA03; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4583863\n"); - end - x = 64'hBFF0000000000001; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4585877\n"); - end - x = 64'h43FFFFFFFFFFC3FE; - y = 64'hC000000000000001; - z = 64'hC0A01869BC9AEAD1; - ans = 64'hC40FFFFFFFFFC400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4587891\n"); - end - x = 64'hBAE000FFFFFFFFFA; - y = 64'hBFC000000011FFFF; - z = 64'h429FBFFFFFFFFFFF; - ans = 64'h429FBFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4589905\n"); - end - x = 64'hBFF0000000000001; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4591919\n"); - end - x = 64'hBA0FFFFFFFFFFFFE; - y = 64'hC340000000000001; - z = 64'h207EC15F8069F3D2; - ans = 64'h3D60000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4593933\n"); - end - x = 64'h4340000200000001; - y = 64'h3FFFFFFFFFFFC0FF; - z = 64'h333EBFFFFFFFFFFF; - ans = 64'h43500001FFFFE080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4595947\n"); - end - x = 64'hBFF0000000000001; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4597961\n"); - end - x = 64'h8001800000000000; - y = 64'hFFF0000000000001; - z = 64'h4EC8E95F80481629; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4599975\n"); - end - x = 64'h290FFFFF0001FFFE; - y = 64'hA330007FFFFFFFF8; - z = 64'h7FFEFFFFFFFFFFEF; - ans = 64'h7FFEFFFFFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4601989\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4604003\n"); - end - x = 64'h802FFEFFFFEFFFFF; - y = 64'h0010000000000000; - z = 64'hB11FFFFFE0000100; - ans = 64'hB11FFFFFE0000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4606017\n"); - end - x = 64'hC06905FEBB773604; - y = 64'hC022A0C0B2A5AE70; - z = 64'h3FE47DD1C6D2DE46; - ans = 64'h409D24B79FC8395C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4608031\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3CA0000000000001; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4610045\n"); - end - x = 64'hC01E25FD8C379C63; - y = 64'h3FD0000000000000; - z = 64'hDAE00000FFFBFFFF; - ans = 64'hDAE00000FFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4612059\n"); - end - x = 64'h7FDFFFFFFFFFFF3E; - y = 64'h3FD1B85566F6674C; - z = 64'hC03FFFFFFFFFFC02; - ans = 64'h7FC1B85566F666E1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4614073\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3FE0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4616087\n"); - end - x = 64'h3CA000200FFFFFFF; - y = 64'h3FF0000000000000; - z = 64'h7FDEE2B9E7B53CAD; - ans = 64'h7FDEE2B9E7B53CAD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4618101\n"); - end - x = 64'h404FFFF81FFFFFFF; - y = 64'h3EB6DBCBFD738A28; - z = 64'h7E244708F1E8F80F; - ans = 64'h7E244708F1E8F80F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4620115\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'h4000000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4622129\n"); - end - x = 64'h5AFFFFFFFFBF7FFE; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h7FDFFFFEFFFFF7FE; - ans = 64'h7FDFFFFEFFFFF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4624143\n"); - end - x = 64'h4030000800004000; - y = 64'hC34FFFFFFFFC3FFF; - z = 64'hE8EFFFFFFFFFF807; - ans = 64'hE8EFFFFFFFFFF807; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4626157\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'h4340000000000000; - z = 64'hBFF0000000000001; - ans = 64'hC350000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4628171\n"); - end - x = 64'hC74007FFFFFFFFF7; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hC3E0100000002000; - ans = 64'hCAA007FFFFFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4630185\n"); - end - x = 64'h38000000FFFFFFFD; - y = 64'hB81FFFF7FFF7FFFE; - z = 64'h41E1DCADEE9FBD6B; - ans = 64'h41E1DCADEE9FBD6B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4632199\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'h7FF0000000000000; - z = 64'h4340000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4634213\n"); - end - x = 64'h400FFFFFFFFFF7DF; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hF378000003FFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4636227\n"); - end - x = 64'h3F4FFFFDFFFFFFBF; - y = 64'hB5FC7E17D9EAF931; - z = 64'hBDAFFFFFFFF800FF; - ans = 64'hBDAFFFFFFFF800FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4638241\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4640255\n"); - end - x = 64'h402FFFE000007FFF; - y = 64'h801FFFFFFFFFFFFF; - z = 64'h401FFFF07FFFFFFF; - ans = 64'h401FFFF07FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4642269\n"); - end - x = 64'hC01FC00003FFFFFF; - y = 64'hDE8FFFEFFFFF7FFF; - z = 64'hF91FFFFDFC000000; - ans = 64'hF91FFFFDFC000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4644283\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4646297\n"); - end - x = 64'hBFFFFFFFFE0003FF; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'h40031ADE702700A8; - ans = 64'h400B1ADE6FA701A8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4648311\n"); - end - x = 64'hA4DE62B77849478B; - y = 64'h3FC51C3A9DF592EF; - z = 64'hC80003FFFFFFFFF0; - ans = 64'hC80003FFFFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4650325\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h4007FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4652339\n"); - end - x = 64'h41DFFFBFFDFFFFFF; - y = 64'hBFF0000000000001; - z = 64'hD5EFFFFFFFF81FFE; - ans = 64'hD5EFFFFFFFF81FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4654353\n"); - end - x = 64'h380D4729AE525911; - y = 64'h42EFFC00007FFFFE; - z = 64'h00210001FFFFFFFE; - ans = 64'h3B0D4380C991AB6B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4656367\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4658381\n"); - end - x = 64'h369F8000000003FF; - y = 64'hC010000000000001; - z = 64'hC07FFFFFFC0FFFFE; - ans = 64'hC07FFFFFFC0FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4660395\n"); - end - x = 64'hC003FFFFFFFFFF7F; - y = 64'hC0EFFFFFFFFFFF10; - z = 64'hB7EFFFFEFFFFDFFF; - ans = 64'h4103FFFFFFFFFEE9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4662409\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4664423\n"); - end - x = 64'hC00FF80000FFFFFF; - y = 64'hFFE0000000000001; - z = 64'h3C2FFFFFFFFFC010; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4666437\n"); - end - x = 64'h41FFFBFEFFFFFFFF; - y = 64'hBFF0FBFFFFFFFFFF; - z = 64'h2F1FFE0000000007; - ans = 64'hC200F9DFF81FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4668451\n"); - end - x = 64'hBFFFFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4670465\n"); - end - x = 64'h37EFF635FC591D37; - y = 64'h0000000000000000; - z = 64'hC03DFFC000000000; - ans = 64'hC03DFFC000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4672479\n"); - end - x = 64'h40150F7B4D5E78B3; - y = 64'hC130000FFFBFFFFF; - z = 64'h43F55EF6C9431743; - ans = 64'h43F55EF6C94311FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4674493\n"); - end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'h0010000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4676507\n"); - end - x = 64'h3E9E07FFFFFFFFFF; - y = 64'h3CA0000000000000; - z = 64'hCAD387355AD2977C; - ans = 64'hCAD387355AD2977C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4678521\n"); - end - x = 64'h4082298B4297E5D7; - y = 64'h42F007FFFFFE0000; - z = 64'hBCAFFFFFFFFC0001; - ans = 64'h438232A00836EC99; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4680535\n"); - end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'h3FD0000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4682549\n"); - end - x = 64'h37EFFFFFFFFF0004; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h0003DFFFFFFFFFFF; - ans = 64'h37DFFFFFFFFF0002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4684563\n"); - end - x = 64'h7FFFFFFDFF7FFFFE; - y = 64'hC0000000001DFFFE; - z = 64'h434FFC0200000000; - ans = 64'h7FFFFFFDFF7FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4686577\n"); - end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'h3FF0000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4688591\n"); - end - x = 64'hB76E07014E0DD9FB; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hC1FFFBFFFFFFFFBF; - ans = 64'hC1FFFBFFFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4690605\n"); - end - x = 64'hB80FFFFFF07FFFFF; - y = 64'hC027E00000000000; - z = 64'h3F50004000FFFFFF; - ans = 64'h3F50004000FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4692619\n"); - end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'h4010000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4694633\n"); - end - x = 64'hBCA000100000001E; - y = 64'h401FFFFFFFFFFFFE; - z = 64'hC030080000000100; - ans = 64'hC030080000000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4696647\n"); - end - x = 64'h000001000000007F; - y = 64'hC001FFFFFFFFF7FF; - z = 64'h00BFFFFFFFFFFFF7; - ans = 64'h00BFFFFF6FFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4698661\n"); - end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'h7FE0000000000000; - z = 64'h3FF0000000000001; + z = 64'hFFEFFFFFFFFFFFFE; ans = 64'hFFEFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -109735,12 +285985,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4700675\n"); + $fwrite(fp,"3735575\n"); end - x = 64'h802876727078CFD2; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'hC008E292C0AAE569; - ans = 64'hC02EAF1720A3892B; + x = 64'h3F10000003BFFFFE; + y = 64'h3E1FFFFFFFFFFFFF; + z = 64'hBFF0000000000000; + ans = 64'hBFEFFFFFFFFFFC00; rn = 1; rz = 0; rm = 0; @@ -109782,106 +286032,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4702689\n"); + $fwrite(fp,"3736189\n"); end - x = 64'hBEAFFFFFFEFFFFFD; - y = 64'h80200000200007FF; - z = 64'hC80003FFDFFFFFFE; - ans = 64'hC80003FFDFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4704703\n"); - end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4706717\n"); - end - x = 64'h3C3007FFBFFFFFFE; + x = 64'hBCA0000000000001; y = 64'h800FFFFFFFFFFFFF; - z = 64'h7FFFFFFFFE07FFFF; - ans = 64'h7FFFFFFFFE07FFFF; + z = 64'hC03B09EA7C43FEA2; + ans = 64'hC03B09EA7C43FEA2; rn = 1; rz = 0; rm = 0; @@ -109923,12 +286079,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4708731\n"); + $fwrite(fp,"3736803\n"); end - x = 64'hBF07FFFFFFFFFFEF; - y = 64'hB7EDB746F5A5CDB3; - z = 64'h3AB5754CEFBE1F72; - ans = 64'h3AB5754CEFBE1F72; + x = 64'hC1EFFFBFFFFFFFFD; + y = 64'h7FFFFEFFFFFFFFFA; + z = 64'h000FFFC07FFFFFFF; + ans = 64'h7FFFFEFFFFFFFFFA; rn = 1; rz = 0; rm = 0; @@ -109970,12 +286126,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4710745\n"); + $fwrite(fp,"3737417\n"); end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + x = 64'h779C6B30A6ACCE58; + y = 64'h8010000000000000; + z = 64'h0010000000000000; + ans = 64'hB7BC6B30A6ACCE58; rn = 1; rz = 0; rm = 0; @@ -110017,12 +286173,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4712759\n"); + $fwrite(fp,"3738031\n"); end - x = 64'h3FBFFFFFFE000100; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hBF8FFFFFFFFD7FFF; - ans = 64'hBF8FFFFFFFFD800F; + x = 64'hBCA0000000000001; + y = 64'h3FBD242FF9F7C369; + z = 64'h403E470AB2DD2D1D; + ans = 64'h403E470AB2DD2D1D; rn = 1; rz = 0; rm = 0; @@ -110064,1516 +286220,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4714773\n"); + $fwrite(fp,"3738645\n"); end - x = 64'h41EC0001FFFFFFFF; - y = 64'hC1F1EEA83E1F966A; - z = 64'h001BD6A7A40A5B07; - ans = 64'hC3EF61A8AA8C4EFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4716787\n"); - end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4718801\n"); - end - x = 64'hBFC000FFFBFFFFFF; - y = 64'hBFE0000000000001; - z = 64'hB7F0000000400010; - ans = 64'h3FB000FFFC000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4720815\n"); - end - x = 64'hBFDF00007FFFFFFF; - y = 64'h380FFFFFFFFF8000; - z = 64'h3FF385598F233ECE; - ans = 64'h3FF385598F233ECE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4722829\n"); - end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'h4007FFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4724843\n"); - end - x = 64'h400FFFFFFFFFFD7F; - y = 64'hC000000000000001; - z = 64'hC013FFFFFDFFFFFF; - ans = 64'hC029FFFFFEFFFEC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4726857\n"); - end - x = 64'hBF8FFDFFFFFFFFFD; - y = 64'hC3FFFFFEFFFC0000; - z = 64'hA82003FFFFFEFFFF; - ans = 64'h439FFDFF000C003D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4728871\n"); - end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4730885\n"); - end - x = 64'hBFD400000007FFFF; - y = 64'hC340000000000000; - z = 64'h4800060000000000; - ans = 64'h4800060000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4732899\n"); - end - x = 64'hDE00000000403FFF; - y = 64'h43E0000001EFFFFF; - z = 64'h40EFF80FFFFFFFFF; - ans = 64'hE1F0000002303FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4734913\n"); - end - x = 64'hBFFFFFFFFFFFFFFE; - y = 64'hFFE0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4736927\n"); - end - x = 64'h801FFFFC00000000; - y = 64'hFFF0000000000000; - z = 64'h2300080000007FFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4738941\n"); - end - x = 64'hBCA0000000080FFF; - y = 64'hBFDEFFFFFFE00000; - z = 64'h403F7FFFFFFBFFFF; - ans = 64'h403F7FFFFFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4740955\n"); - end - x = 64'hC000000000000000; - y = 64'h0000000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4742969\n"); - end - x = 64'hBDF82AE78C741692; - y = 64'h0010000000000000; - z = 64'hC84FFFFFFE000FFE; - ans = 64'hC84FFFFFFE000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4744983\n"); - end - x = 64'hCA700003FFFDFFFF; - y = 64'hB806FFFFFFFFFFFF; - z = 64'hFFFFEFFEFFFFFFFF; - ans = 64'hFFFFEFFEFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4746997\n"); - end - x = 64'hC000000000000000; - y = 64'h3CA0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4749011\n"); - end - x = 64'hBF83F15F996FACE6; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h3FB00FFFF8000000; - ans = 64'h3FB00FFFF8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4751025\n"); - end - x = 64'hBFB00001FFFFFE00; - y = 64'h37EFFFFFFFBFFFFD; - z = 64'hC08FF80000000010; - ans = 64'hC08FF80000000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4753039\n"); - end - x = 64'hC000000000000000; - y = 64'h3FE0000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4755053\n"); - end - x = 64'h400800001FFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h7FEFFFFFFFFF9FFF; - ans = 64'h7FEFFFFFFFFF9FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4757067\n"); - end - x = 64'h3801D02705E6F605; - y = 64'hFFD0008000000004; - z = 64'h43EF7FFFFFFFFFFE; - ans = 64'hF7E1D0B5871F2541; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4759081\n"); - end - x = 64'hC000000000000000; - y = 64'h4000000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4761095\n"); - end - x = 64'hB7FFFFFF07FFFFFF; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h43F0000100007FFF; - ans = 64'h43F0000100007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4763109\n"); - end - x = 64'h436F8BB30527C3E1; - y = 64'hC3DFFF0000400000; - z = 64'hC5E000000FFFFFEF; - ans = 64'hC75F8AB6C7CEB229; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4765123\n"); - end - x = 64'hC000000000000000; - y = 64'h4340000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC350000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4767137\n"); - end - x = 64'hB7FF36B99B086A9B; - y = 64'h434FFFFFFFFFFFFF; - z = 64'hC1AF142D1ED4E9B1; - ans = 64'hC1AF142D1ED4E9B1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4769151\n"); - end - x = 64'h403FFB0000000000; - y = 64'h29BF3D5BEC0E2D80; - z = 64'hB7FFFFFFFFFDFFFF; - ans = 64'hB7FFFFFFFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4771165\n"); - end - x = 64'hC000000000000000; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4773179\n"); - end - x = 64'hC00FFFFFF8000001; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hB7FFDFF800000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4775193\n"); - end - x = 64'h3FE0000000000027; - y = 64'hBFFFFFFFFFFFFF77; - z = 64'h40600001FFFFDFFF; - ans = 64'h405FC003FFFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4777207\n"); - end - x = 64'hC000000000000000; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4779221\n"); - end - x = 64'h7FE000001000003F; + x = 64'h380EFFFFFFFFFFFD; y = 64'h8010000000000001; - z = 64'hC00040003FFFFFFF; - ans = 64'hC010200028000020; + z = 64'hBFA501B829A23C23; + ans = 64'hBFA501B829A23C23; rn = 1; rz = 0; rm = 0; @@ -111615,1046 +286267,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4781235\n"); + $fwrite(fp,"3739259\n"); end - x = 64'h433FC00004000000; - y = 64'hC7E0000000020010; - z = 64'hBFBFFFFFFEFFFEFF; - ans = 64'hCB2FC0000403F820; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4783249\n"); - end - x = 64'hC000000000000000; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4785263\n"); - end - x = 64'h001FFFFE0000007F; - y = 64'hBFD0000000000001; - z = 64'h3CA6780098C722B0; - ans = 64'h3CA6780098C722B0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4787277\n"); - end - x = 64'hD9F000003DFFFFFF; - y = 64'h41EFE007FFFFFFFF; - z = 64'hC0DFFFFFFFFFC1FF; - ans = 64'hDBEFE0087B841EFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4789291\n"); - end - x = 64'hC000000000000000; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4791305\n"); - end - x = 64'hC00636536D8AD40E; - y = 64'hBFF0000000000001; - z = 64'h400F97076662A920; - ans = 64'h401AE6AD69F6BE98; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4793319\n"); - end - x = 64'h3FCFF3FFFFFFFFFF; - y = 64'h310000FFFF800000; - z = 64'h38100000800003FE; - ans = 64'h38100000800003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4795333\n"); - end - x = 64'hC000000000000000; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h4022000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4797347\n"); - end - x = 64'hC1CE00000000FFFF; - y = 64'hC010000000000000; - z = 64'h3CA001FFFFFFFEFE; - ans = 64'h41EE00000000FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4799361\n"); - end - x = 64'hC00000000000801F; - y = 64'hBFF000000FF7FFFF; - z = 64'hC1FFFFFE00000001; - ans = 64'hC1FFFFFDFFE00001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4801375\n"); - end - x = 64'hC000000000000000; - y = 64'hC340000000000001; - z = 64'hC340000000000000; - ans = 64'h4340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4803389\n"); - end - x = 64'hAEFCE4D2B75F2241; - y = 64'hFFE0000000000000; - z = 64'hBCAFFFFFFFFF801F; - ans = 64'h6EECE4D2B75F2241; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4805403\n"); - end - x = 64'h3FB6726C7090ABFA; - y = 64'h001000000FFFFFE0; - z = 64'h40200000004003FF; - ans = 64'h40200000004003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4807417\n"); - end - x = 64'hC000000000000000; - y = 64'hFFF0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4809431\n"); - end - x = 64'h9EDFFFFFFEBFFFFF; - y = 64'h0000000000000000; - z = 64'h7FDFBC79F86CB8D2; - ans = 64'h7FDFBC79F86CB8D2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4811445\n"); - end - x = 64'h9F90040000001FFF; - y = 64'h8000FFE4B843FAAD; - z = 64'hB80FF7FFFFFE0000; - ans = 64'hB80FF7FFFFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4813459\n"); - end - x = 64'hC000000000000001; - y = 64'h0010000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4815473\n"); - end - x = 64'h3FEF5A535F649EA9; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h3EF80CBAF04E7D23; - ans = 64'h3EF80CBAF04E7D23; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4817487\n"); - end - x = 64'hC8400007FFFFFFDE; - y = 64'h401FFFFFC0008000; - z = 64'h41F0000000000060; - ans = 64'hC8700007E0002FDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4819501\n"); - end - x = 64'hC000000000000001; - y = 64'h3FD0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hBFF8000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4821515\n"); - end - x = 64'h3FC080001FFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h3E60000400000007; - ans = 64'h3FB08000A0001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4823529\n"); - end - x = 64'hC3CFFC00007FFFFF; - y = 64'h3C2BB996E37CCEFC; - z = 64'h769000000005FFFE; - ans = 64'h769000000005FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4825543\n"); - end - x = 64'hC000000000000001; - y = 64'h3FF0000000000000; + x = 64'hBCA0000000000001; + y = 64'h47FFFC00003FFFFF; z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFE; + ans = 64'hC4AFFBFFC0400001; rn = 1; rz = 0; rm = 0; @@ -112696,12 +286314,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4827557\n"); + $fwrite(fp,"3739873\n"); end - x = 64'h3FF003FFFFFDFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'hFFFFFFFDFFFFFFFB; - ans = 64'hFFFFFFFDFFFFFFFB; + x = 64'h8015D7ABA4BF48ED; + y = 64'h3F1FFFFFF7FFFFFE; + z = 64'h7FEE2DBEE5C2D97E; + ans = 64'h7FEE2DBEE5C2D97E; rn = 1; rz = 0; rm = 0; @@ -112743,17824 +286361,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4829571\n"); + $fwrite(fp,"3740487\n"); end - x = 64'h0000000000000000; - y = 64'h41DFFFFFF807FFFE; - z = 64'h42100000003FFFDF; - ans = 64'h42100000003FFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4831585\n"); - end - x = 64'hC000000000000001; - y = 64'h400FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4833599\n"); - end - x = 64'h381905D4F9CFD211; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h47F01FFDFFFFFFFE; - ans = 64'h47F01FFDFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4835613\n"); - end - x = 64'hFFE00000001F8000; - y = 64'hC3CFFE0000008000; - z = 64'hC02007FFFFBFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4837627\n"); - end - x = 64'hC000000000000001; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4839641\n"); - end - x = 64'hAEED32209391C748; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h41D63870E0F49A36; - ans = 64'hEEED32209391C747; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4841655\n"); - end - x = 64'h37EE6E74F86EAA00; - y = 64'h000FFFFFFE080000; - z = 64'hBFC0000000F80000; - ans = 64'hBFC0000000F80000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4843669\n"); - end - x = 64'hC000000000000001; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4845683\n"); - end - x = 64'hC00D7421886BB409; - y = 64'h8000000000000001; - z = 64'h43FFFFF000000008; - ans = 64'h43FFFFF000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4847697\n"); - end - x = 64'h29984D3022BF3429; - y = 64'h000000000005FFFF; - z = 64'h322FFFBEFFFFFFFF; - ans = 64'h322FFFBEFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4849711\n"); - end - x = 64'hC000000000000001; - y = 64'h801FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4851725\n"); - end - x = 64'hC0E1EAD1644C2360; - y = 64'hBCA0000000000001; - z = 64'hC3DFFFFFFFFE7FFF; - ans = 64'hC3DFFFFFFFFE7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4853739\n"); - end - x = 64'hBEA000002001FFFF; - y = 64'hC1CEF0DEA2CE737B; - z = 64'h400E000000000000; - ans = 64'h407F2CDEE0B40EDB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4855753\n"); - end - x = 64'hC000000000000001; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4857767\n"); - end - x = 64'hC3D0000001BFFFFF; - y = 64'hBFE0000000000001; - z = 64'h2140000000FFDFFF; - ans = 64'h43C0000001C00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4859781\n"); - end - x = 64'h4DD40D9CD154CAEF; - y = 64'hF22FFF7FFFBFFFFF; - z = 64'hC03007FFFFDFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4861795\n"); - end - x = 64'hC000000000000001; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4863809\n"); - end - x = 64'h3F30000020000000; - y = 64'hC000000000000000; - z = 64'hBFCFFFFFC001FFFF; - ans = 64'hBFD007FFE0110000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4865823\n"); - end - x = 64'h802FFFFFFFC001FE; - y = 64'hC1E123B4086EBB50; - z = 64'h3FB5797E09A179E2; - ans = 64'h3FB5797E09A179E2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4867837\n"); - end - x = 64'hC000000000000001; - y = 64'hC010000000000001; - z = 64'hBFF0000000000001; - ans = 64'h401C000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4869851\n"); - end - x = 64'hB7FE380190D1E449; - y = 64'hC340000000000000; - z = 64'h3690200000010000; - ans = 64'h3B4E380190D1E449; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4871865\n"); - end - x = 64'h3E9FFFBFC0000000; - y = 64'h5072000080000000; - z = 64'hAE9FF8001FFFFFFF; - ans = 64'h4F21FFDC5BFEFF00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4873879\n"); - end - x = 64'hC000000000000001; - y = 64'hFFE0000000000001; - z = 64'h4340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4875893\n"); - end - x = 64'hC05FFF8100000000; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'h419000000010FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4877907\n"); - end - x = 64'hBF2EFFFFFFBFFFFF; - y = 64'h001A635FFEB94418; - z = 64'h3FF00100000001FE; - ans = 64'h3FF00100000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4879921\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'h0000000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4881935\n"); - end - x = 64'hC7FFFF0000001FFF; - y = 64'h000FFFFFFFFFFFFE; - z = 64'h401B56E379B8AB6F; - ans = 64'h401B56E379B8AB6F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4883949\n"); - end - x = 64'hC1CFFFFFFFFFF6FF; - y = 64'h43CFFFFFFF7FFFF0; - z = 64'hC1CFFFFFFFFFFFE8; - ans = 64'hC5AFFFFFFF7FF6EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4885963\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'h3CA0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCC7FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4887977\n"); - end - x = 64'h37E3CAF180C9430E; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h3FDF22A7D23C7623; - ans = 64'h3FDF22A7D23C7623; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4889991\n"); - end - x = 64'hC31FEFF7FFFFFFFE; - y = 64'h407F14DABF153AF4; - z = 64'h43C9F50DA1A060A1; - ans = 64'h43C233BB7E80A07D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4892005\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'h3FE0000000000000; - z = 64'h3FF0000000000001; - ans = 64'hBFEFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4894019\n"); - end - x = 64'hBFF080007FFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h41F0002003FFFFFF; - ans = 64'h41F0002003EF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4896033\n"); - end - x = 64'h000FFFFFEFFFDFFF; - y = 64'hC3E004FFFFFFFFFE; - z = 64'hBC3FFBFFFFFFFFF7; - ans = 64'hBC3FFBFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4898047\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4900061\n"); - end - x = 64'h3FFFFFFF7FFFFFEF; - y = 64'h400FFFFFFFFFFFFF; - z = 64'hE2F801FFFFFFFFFF; - ans = 64'hE2F801FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4902075\n"); - end - x = 64'hC00FFFFFFDFFFFEE; - y = 64'hC028D9A8BEA71866; - z = 64'hCE2FFFFFFFFFFFC6; - ans = 64'hCE2FFFFFFFFFFFC6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4904089\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4906103\n"); - end - x = 64'h3EB7FFFFFFFFFFF0; - y = 64'h434FFFFFFFFFFFFF; - z = 64'h3FC01FFFFFFFFFEF; - ans = 64'h42180000000080EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4908117\n"); - end - x = 64'h434FFE0000000003; - y = 64'h3F050506FA43403E; - z = 64'hC036D0C0E5DF8B63; - ans = 64'h426503B6A9D0C1F4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4910131\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4912145\n"); - end - x = 64'hBFB000020003FFFE; - y = 64'h7FF0000000000001; - z = 64'h5510FFFFFFFF7FFE; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4914159\n"); - end - x = 64'hEB2000000000000D; - y = 64'hBCAFFFFFFFC0003F; - z = 64'h38E3FFFFFFFF7FFF; - ans = 64'h67DFFFFFFFC00059; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4916173\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4918187\n"); - end - x = 64'hC020004000000040; - y = 64'h8010000000000001; - z = 64'hC1FFFFF000800000; - ans = 64'hC1FFFFF000800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4920201\n"); - end - x = 64'h40AFFFFBFFFFFFF6; - y = 64'hC20000000003FFFD; - z = 64'hC01FFDFFFE000000; - ans = 64'hC2BFFFFC000807EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4922215\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4924229\n"); - end - x = 64'hB80F000010000000; - y = 64'hBFD0000000000000; - z = 64'h43C0FDA6886F0D30; - ans = 64'h43C0FDA6886F0D30; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4926243\n"); - end - x = 64'hBF2F80007FFFFFFF; - y = 64'h76D0000000006FFF; - z = 64'h47E0FFFFFF7FFFFE; - ans = 64'hF60F80008000DC7D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4928257\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'hBFE0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4930271\n"); - end - x = 64'h37EFFEFFDFFFFFFF; - y = 64'hBFF0000000000000; - z = 64'hB7EFFFD7FFFFFFFF; - ans = 64'hB7FFFF6BEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4932285\n"); - end - x = 64'h43C07FBFFFFFFFFE; - y = 64'hCA72000000000007; - z = 64'hB99F3903BA9AF78B; - ans = 64'hCE428FB800000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4934299\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'hC000000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h4020000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4936313\n"); - end - x = 64'hC7E0000003FFFFFF; - y = 64'hC010000000000000; - z = 64'h395000001FFFC000; - ans = 64'h4800000003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4938327\n"); - end - x = 64'h4047C422625C8DFB; - y = 64'h3FF000010003FFFF; - z = 64'h42E0000000000700; - ans = 64'h42E0000000000CF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4940341\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'hC340000000000001; - z = 64'h3FF0000000000001; - ans = 64'h4360000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4942355\n"); - end - x = 64'hBFBFFFFFBFFFF7FF; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h40196D6B50F2A50C; - ans = 64'h431FFFFFBFFFF816; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4944369\n"); - end - x = 64'h489FFFEFFFFFEFFE; - y = 64'hB6EFFFFFFFBFFFFC; - z = 64'h3FBFFFFFFFF7EFFE; - ans = 64'h3FB800040007F3F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4946383\n"); - end - x = 64'hC00FFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - z = 64'hC340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4948397\n"); - end - x = 64'hC3F99F723708B50D; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h476000400000003F; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4950411\n"); - end - x = 64'hC09FFFFFC000007F; - y = 64'hC800000000040FFE; - z = 64'hBD0000000001EFFF; - ans = 64'h48AFFFFFC008207B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4952425\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'h0010000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4954439\n"); - end - x = 64'h3FEFC10000000000; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h3FC001FFFF7FFFFF; - ans = 64'h3FC001FFFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4956453\n"); - end - x = 64'hBFEFFFFFBFFFFFEF; - y = 64'h4000040FFFFFFFFE; - z = 64'h51D868ED5ABEC329; - ans = 64'h51D868ED5ABEC329; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4958467\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'h3FD0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4960481\n"); - end - x = 64'h42FB1185BF70CCEC; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h14904C9B2DC78348; - ans = 64'h42EB1185BF70CCEB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4962495\n"); - end - x = 64'h4020000000010000; - y = 64'h47FFFFFFFFFC2000; - z = 64'h3CA2F1AC81C05D0C; - ans = 64'h482FFFFFFFFE2000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4964509\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hC013FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4966523\n"); - end - x = 64'hBFC0001FFE000000; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h43EE9D7600EAEAAB; - ans = 64'h43EE9D7600EAEAAB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4968537\n"); - end - x = 64'h001F53634F83EF23; - y = 64'hC1FFFFF400000000; - z = 64'h3FC725099455170F; - ans = 64'h3FC725099455170F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4970551\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4972565\n"); - end - x = 64'h4320037FFFFFFFFF; - y = 64'h4010000000000001; - z = 64'h41FDC4B3A046B212; - ans = 64'h43400380EE259D02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4974579\n"); - end - x = 64'hC3D000000001000F; - y = 64'h3FF000020000FFFF; - z = 64'hC03FFFF00000001E; - ans = 64'hC3D000020002000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4976593\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4978607\n"); - end - x = 64'h480FFFFFFBFBFFFF; - y = 64'h7FE0000000000001; - z = 64'hB800000083FFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4980621\n"); - end - x = 64'h41D07FFFFF800000; - y = 64'hC010FFFFFFBFFFFE; - z = 64'hBFD07FFFFFFFFFDF; - ans = 64'hC1F187FFFF3A1FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4982635\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4984649\n"); - end - x = 64'h6EC000000007FDFF; - y = 64'h8000000000000001; - z = 64'hC1D93B5D4A2A8ABD; - ans = 64'hC1D93B5D4A2A8ABD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4986663\n"); - end - x = 64'hC3EFFDFFFFFFF7FE; - y = 64'hFFE57370E59E6D25; - z = 64'hC007FFFFFFFF7FFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4988677\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4990691\n"); - end - x = 64'h7FEFFFFFFC004000; - y = 64'hBCA0000000000000; - z = 64'h409C00001FFFFFFF; - ans = 64'hFC9FFFFFFC004000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4992705\n"); - end - x = 64'hBFC003FFFFFFF000; - y = 64'h982FFFFFFF7EFFFF; - z = 64'hC7EFFFFFBFFFDFFF; - ans = 64'hC7EFFFFFBFFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4994719\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'hBFD0000000000001; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4996733\n"); - end - x = 64'hC02072F3B0873040; - y = 64'hBFE0000000000000; - z = 64'h2178FF86D6E78F62; - ans = 64'h401072F3B0873040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4998747\n"); - end - x = 64'h7FF0000001FFFFFB; - y = 64'hC3D0000000080400; - z = 64'hBFD0000000001F7E; - ans = 64'h7FF8000001FFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5000761\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'hBFF0000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5002775\n"); - end - x = 64'h4181A83E99639AD7; - y = 64'hC000000000000000; - z = 64'h3CB4B4507335CAB2; - ans = 64'hC191A83E99639AD7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5004789\n"); - end - x = 64'h27C1ED6D778B4BD4; - y = 64'hBA8869EBDC7AAE3D; - z = 64'hBFDFFFFFDFFFFFDE; - ans = 64'hBFDFFFFFDFFFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5006803\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'hC010000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h4030000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5008817\n"); - end - x = 64'hBCCE2E656DD76AF6; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h40582EA8FFAB0667; - ans = 64'h40582EA8FFAB0667; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5010831\n"); - end - x = 64'hC3E43CF321BA68FA; - y = 64'h9D34000001000000; - z = 64'hC005BF51A5846459; - ans = 64'hC005BF51A5846459; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5012845\n"); - end - x = 64'hC00FFFFFFFFFFFFE; - y = 64'hFFE0000000000000; - z = 64'hBFF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5014859\n"); - end - x = 64'h00000004000007FE; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hC030000003FFFEFF; - ans = 64'hC0300001040000FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5016873\n"); - end - x = 64'h40000010007FFFFE; - y = 64'h3F6B3DB4BB3D6728; - z = 64'h3FD095716EC3B12B; - ans = 64'h3FD10268AEAAE16B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5018887\n"); - end - x = 64'hC010000000000000; - y = 64'h0000000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5020901\n"); - end - x = 64'h41EFFF80000007FF; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hC00400007FFFFFFF; - ans = 64'hC00400007FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5022915\n"); - end - x = 64'hC7FC0003FFFFFFFF; - y = 64'h3CCFFFFF80000000; - z = 64'hBFB000800001FFFF; - ans = 64'hC4DC00038FFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5024929\n"); - end - x = 64'hC010000000000000; - y = 64'h001FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5026943\n"); - end - x = 64'hBFFEFC43BDEC594F; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'hC1D0007FFFFF0000; - ans = 64'hC1D0007FFFFF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5028957\n"); - end - x = 64'h3FEFFFFFFFFFFFC3; - y = 64'h559E4A558F2A87B9; - z = 64'h37EFFBFEFFFFFFFF; - ans = 64'h559E4A558F2A877F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5030971\n"); - end - x = 64'hC010000000000000; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5032985\n"); - end - x = 64'hC3F3FFFFFFFFFFEF; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'hC014BF12499BEAA6; - ans = 64'hC3F3FFFFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5034999\n"); - end - x = 64'hFD6FFFFFFEFFFEFF; - y = 64'hC5600003FFFF0000; - z = 64'h6FF03FFFFFFFFFEF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5037013\n"); - end - x = 64'hC010000000000000; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'hC01BFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5039027\n"); - end - x = 64'h37FF6974A0A2DE26; - y = 64'h4000000000000001; - z = 64'h9EFD901931AB4FD9; - ans = 64'h380F6974A0A2DE28; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5041041\n"); - end - x = 64'h43A00000017FFFFF; - y = 64'h002FFC000000000F; - z = 64'h47F56A050C6B635C; - ans = 64'h47F56A050C6B635C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5043055\n"); - end - x = 64'hC010000000000000; - y = 64'h401FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5045069\n"); - end - x = 64'h3F67C855AE00CE43; - y = 64'h4340000000000001; - z = 64'h43E6F149C1994369; - ans = 64'h43E6F14CBAA3F929; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5047083\n"); - end - x = 64'hBA5E0000000FFFFF; - y = 64'hC03FC000000001FE; - z = 64'hC80003FFFC000000; - ans = 64'hC80003FFFC000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5049097\n"); - end - x = 64'hC010000000000000; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5051111\n"); - end - x = 64'hBFE339A58291C4AF; - y = 64'h7FF0000000000001; - z = 64'h52AFA392C17F0D10; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5053125\n"); - end - x = 64'h41F20CE452B1F68A; - y = 64'h00279A7CD560FECE; - z = 64'h3FFFFFE000040000; - ans = 64'h3FFFFFE000040000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5055139\n"); - end - x = 64'hC010000000000000; - y = 64'h800FFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5057153\n"); - end - x = 64'hC018080000000000; - y = 64'h8010000000000000; - z = 64'hBFDFFFFF800001FE; - ans = 64'hBFDFFFFF800001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5059167\n"); - end - x = 64'h3F90B65D53ED7D74; - y = 64'h43EEF244B81AFC9D; - z = 64'hEA94A4603D3F58EA; - ans = 64'hEA94A4603D3F58EA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5061181\n"); - end - x = 64'hC010000000000000; - y = 64'hBCA0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5063195\n"); - end - x = 64'h415FFFFDFFDFFFFF; - y = 64'hBFD0000000000000; - z = 64'hBA2FFFFFFFFFFF3E; - ans = 64'hC13FFFFDFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5065209\n"); - end - x = 64'hC01DFFFFFFFFFF80; - y = 64'h434794F52A5C4334; - z = 64'hBFEFFFFC7FFFFFFE; - ans = 64'hC3761BA5D7B67EA2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5067223\n"); - end - x = 64'hC010000000000000; - y = 64'hBFE0000000000001; - z = 64'h4340000000000000; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5069237\n"); - end - x = 64'h002FFC0080000000; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hC03FF3FFFFFFFFFF; - ans = 64'hC03FF3FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5071251\n"); - end - x = 64'h403FFFFFFFFFFFDB; - y = 64'h423356B030815738; - z = 64'hBF9080007FFFFFFF; - ans = 64'h428356B030815701; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5073265\n"); - end - x = 64'hC010000000000000; - y = 64'hC000000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5075279\n"); - end - x = 64'h480000100001FFFE; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hBFCAFAB20C86E4F5; - ans = 64'hC82000100001FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5077293\n"); - end - x = 64'h41A69AC8BDFDB461; - y = 64'hC3D0083FFFFFFFFF; - z = 64'h41D8313B8D51B193; - ans = 64'hC586A6708D7FAB31; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5079307\n"); - end - x = 64'hC010000000000000; - y = 64'hC340000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h4360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5081321\n"); - end - x = 64'h76FFFFFFFDFFFF7F; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h000000FFF7FFFFFF; - ans = 64'hFA5FFFFFFDFFFF7D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5083335\n"); - end - x = 64'h401000FFFFFFFFFF; - y = 64'h4BA80119D03CC382; - z = 64'h800FE0000000001E; - ans = 64'h4BC80299E1D9C74D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5085349\n"); - end - x = 64'hC010000000000000; - y = 64'hFFF0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5087363\n"); - end - x = 64'h3D1100FFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h4130200000000020; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5089377\n"); - end - x = 64'hC0300000007FFFFF; - y = 64'h801FFFFFFFF80FFF; - z = 64'h3F80080FFFFFFFFF; - ans = 64'h3F80080FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5091391\n"); - end - x = 64'hC010000000000001; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5093405\n"); - end - x = 64'h3B0000801FFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - z = 64'hC0B0000000EFFFFF; - ans = 64'hC0B0000000EFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5095419\n"); - end - x = 64'hC03FEFFFFFFFFFF0; - y = 64'h802000000000007A; - z = 64'h4000000000041FFF; - ans = 64'h4000000000041FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5097433\n"); - end - x = 64'hC010000000000001; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5099447\n"); - end - x = 64'hC802BDB003FB32E9; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h8020088000000000; - ans = 64'hC7F2BDB003FB32E8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5101461\n"); - end - x = 64'h543000200000003F; - y = 64'hC02D1293AAABC916; - z = 64'hBDDFFFFFFFFFFEBE; - ans = 64'hD46D12CDCFD31EE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5103475\n"); - end - x = 64'hC010000000000001; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5105489\n"); - end - x = 64'hCE598DADDC5729FE; - y = 64'h3FF0000000000001; - z = 64'h3810207FFFFFFFFE; - ans = 64'hCE598DADDC572A00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5107503\n"); - end - x = 64'h43FFFFFFBFFFFBFF; - y = 64'hC6054EA060D6C64D; - z = 64'hBD1FFFE000000007; - ans = 64'hCA154EA0363982E1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5109517\n"); - end - x = 64'hC010000000000001; - y = 64'h400FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hC031000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5111531\n"); - end - x = 64'h3DEFFE0000003FFF; - y = 64'h4010000000000001; - z = 64'h7FFFFFFFFFF7FFFF; - ans = 64'h7FFFFFFFFFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5113545\n"); - end - x = 64'h40AB72C184FC22A3; - y = 64'hC390000000002800; - z = 64'h0000000000040007; - ans = 64'hC44B72C184FC6742; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5115559\n"); - end - x = 64'hC010000000000001; - y = 64'h434FFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'hC36C000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5117573\n"); - end - x = 64'h3FE0003FFFFFFFDF; - y = 64'h7FE0000000000000; - z = 64'h3F0C99E416733E31; - ans = 64'h7FD0003FFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5119587\n"); - end - x = 64'h407FFFF7FBFFFFFF; - y = 64'hCA6FFFFFFFFFBFBF; - z = 64'h4030000840000000; - ans = 64'hCAFFFFF7FBFFBFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5121601\n"); - end - x = 64'hC010000000000001; - y = 64'h7FF0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5123615\n"); - end - x = 64'hBB82B0937960FD27; - y = 64'h8000000000000000; - z = 64'h0020120000000000; - ans = 64'h0020120000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5125629\n"); - end - x = 64'h3FE5EB855F64990C; - y = 64'hC3DFFFFFFFFF7F7E; - z = 64'hA2DFFFFF8000007F; - ans = 64'hC3D5EB855F644105; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5127643\n"); - end - x = 64'hC010000000000001; - y = 64'h8010000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5129657\n"); - end - x = 64'h75DFFFFFFFFFF806; - y = 64'hBCA0000000000000; - z = 64'h3E80001F7FFFFFFF; - ans = 64'hF28FFFFFFFFFF806; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5131671\n"); - end - x = 64'h4024BE018F92CCC8; - y = 64'hB817E6B3FFEB70F6; - z = 64'h427FBFBFFFFFFFFF; - ans = 64'h427FBFBFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5133685\n"); - end - x = 64'hC010000000000001; - y = 64'hBFD0000000000001; - z = 64'h3FF0000000000001; - ans = 64'h4000000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5135699\n"); - end - x = 64'hBC58A7F283B15AA6; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'hC00FF7FFFFFFFEFF; - ans = 64'hC00FF7FFFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5137713\n"); - end - x = 64'h213FFFC000002000; - y = 64'hBFC39F7F419ECA3B; - z = 64'h3E1FFDFFFFFFEFFE; - ans = 64'h3E1FFDFFFFFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5139727\n"); - end - x = 64'hC010000000000001; - y = 64'hBFF0000000000000; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5141741\n"); - end - x = 64'h37EA3353806450BA; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hB803FFFFFFFFF7FF; - ans = 64'hB8108CD4E019102E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5143755\n"); - end - x = 64'hC7E69C5B6A0DA2F1; - y = 64'hFFE0000200000FFE; - z = 64'h41C030A162E322F9; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5145769\n"); - end - x = 64'hC010000000000001; - y = 64'hC010000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5147783\n"); - end - x = 64'hC1FFF7FFFFFFFE00; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hBF38000000000040; - ans = 64'h422FF7FFFFFFFDCE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5149797\n"); - end - x = 64'h3FD00004000001FE; - y = 64'h53E98944E3420553; - z = 64'h401000000807FFFF; - ans = 64'h53C9894B45934151; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5151811\n"); - end - x = 64'hC010000000000001; - y = 64'hFFE0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5153825\n"); - end - x = 64'hBFE0000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hB45C000008000000; - ans = 64'h7FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5155839\n"); - end - x = 64'h2A901FC000000000; - y = 64'h7DEFFFFFFFFFDEFE; - z = 64'h3AD000FFBFFFFFFF; - ans = 64'h68901FBFFFFFEF5E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5157853\n"); - end - x = 64'hC010000000000001; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5159867\n"); - end - x = 64'hC76FFFFC00003FFF; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hC80BFFFF7FFFFFFE; - ans = 64'hC80BFFFF7FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5161881\n"); - end - x = 64'h43FFFFFFFC000100; - y = 64'hFFEFFFC002000000; - z = 64'h43F00000007FFBFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5163895\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5165909\n"); - end - x = 64'hBDDA8046AB558986; - y = 64'h3CA0000000000001; - z = 64'h3FA000002000007F; - ans = 64'h3FA000002000007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5167923\n"); - end - x = 64'hBCAFFFFDF7FFFFFE; - y = 64'h366FFFFFFE1FFFFF; - z = 64'hB20F000000000007; - ans = 64'hB3300002DB10000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5169937\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5171951\n"); - end - x = 64'h9720000000000103; - y = 64'h3FE0000000000001; - z = 64'h401B8A2396EC8564; - ans = 64'h401B8A2396EC8564; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5173965\n"); - end - x = 64'hBFFFFFFFFF7F7FFE; - y = 64'hC003FFFFFFFFFFF6; - z = 64'hCEA3CAF6C0E272A7; - ans = 64'hCEA3CAF6C0E272A7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5175979\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC02FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5177993\n"); - end - x = 64'h3B2FFFFFFFEFFFFC; - y = 64'h4000000000000001; - z = 64'h43F0007FFFFFFC00; - ans = 64'h43F0007FFFFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5180007\n"); - end - x = 64'hC1D001001FFFFFFE; - y = 64'h8021509C47E8A603; - z = 64'h3FC0007BFFFFFFFF; - ans = 64'h3FC0007BFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5182021\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'hC04F7FFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5184035\n"); - end - x = 64'hBF410509ACBE8DD0; - y = 64'h4340000000000000; - z = 64'hBDC007F7FFFFFFFF; - ans = 64'hC2910509ACBE8DD0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5186049\n"); - end - x = 64'hC34FFFFFDFFF8000; - y = 64'h3FF80007FFFFFFFF; - z = 64'hCA50000400000001; - ans = 64'hCA50000400000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5188063\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'h7FE0000000000001; - z = 64'hC340000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5190077\n"); - end - x = 64'hB4BFFFFC0000FFFF; - y = 64'h7FF0000000000000; - z = 64'hD5C7770CA9F353D1; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5192091\n"); - end - x = 64'h7B6E5B7D682D63C8; - y = 64'h41E0008007FFFFFF; - z = 64'hBE1ABB9F82864AF4; - ans = 64'h7D5E5C70534663E5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5194105\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'h8000000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5196119\n"); - end - x = 64'h40631D93C28E029D; - y = 64'h8010000000000000; - z = 64'hC80CB4CE53B7E24E; - ans = 64'hC80CB4CE53B7E24E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5198133\n"); - end - x = 64'hBF40000804000000; - y = 64'h3CCFFFFF7FFEFFFE; - z = 64'hBE9000000FFFFFFF; - ans = 64'hBE90000010001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5200147\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'hBCA0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CD4000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5202161\n"); - end - x = 64'h423C64DF6CA8AA39; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h3FF1AE3AB5F11D36; - ans = 64'h3FF1AE1E5111B08D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5204175\n"); - end - x = 64'hBFC00007FFFFFFFD; - y = 64'h40EDFFFFFFFFFFFF; - z = 64'hCC402000000FFFFE; - ans = 64'hCC402000000FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5206189\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'hBFE0000000000000; - z = 64'hBFF0000000000001; - ans = 64'h4007FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5208203\n"); - end - x = 64'h434B1104A80420DF; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hAF7FFFFFFFFFFFDA; - ans = 64'hC34B1104A80420DD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5210217\n"); - end - x = 64'hFC70000000FFFFEF; - y = 64'h480000000000401F; - z = 64'h001AB256227249D3; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5212231\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'hC000000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5214245\n"); - end - x = 64'h3CB00000000FFFFF; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'hC9EDFEFFFFFFFFFF; - ans = 64'hC9EDFEFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5216259\n"); - end - x = 64'h40C00000000101FF; - y = 64'hBCC0003FFFFFFFDF; - z = 64'h37E000000000FFFF; - ans = 64'hBD900040000101E2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5218273\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5220287\n"); - end - x = 64'hB7FC6F7E42E2497D; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'h4340000000000022; - ans = 64'h4340000000000022; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5222301\n"); - end - x = 64'hC28A5C919019FE50; - y = 64'hB7EFFFFFFFC3FFFF; - z = 64'hFFE03FDFFFFFFFFF; - ans = 64'hFFE03FDFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5224315\n"); - end - x = 64'hC01FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5226329\n"); - end - x = 64'hBFCFFFFFFFFFFF9E; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h7FF47307D935867F; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5228343\n"); - end - x = 64'hA7ABDC010B80E854; - y = 64'h40200F8000000000; - z = 64'h37E020000000003F; - ans = 64'h37E020000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5230357\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5232371\n"); - end - x = 64'hBFFFFFFFFF0007FF; - y = 64'h0010000000000001; - z = 64'h5DBFFFF00003FFFF; - ans = 64'h5DBFFFF00003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5234385\n"); - end - x = 64'hBF1FFFFFE0FFFFFF; - y = 64'hBFCFFFFFFBFFFF00; - z = 64'hBF9000001FFFFC00; - ans = 64'hBF8FF00040117800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5236399\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5238413\n"); - end - x = 64'h3B0FFFFFF3FFFFFE; - y = 64'h3FD0000000000001; - z = 64'h3FBAB51472AC76F4; - ans = 64'h3FBAB51472AC76F4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5240427\n"); - end - x = 64'h47FE17F4025A7DEB; - y = 64'hB7F000000FFFFFEF; - z = 64'h41C000400000001F; - ans = 64'h41C0003FFF0F407E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5242441\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5244455\n"); - end - x = 64'h8010000000803FFF; - y = 64'h3FF0000000000001; - z = 64'h000FFFE07FFFFFFF; - ans = 64'h8000001F80804001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5246469\n"); - end - x = 64'h3FEEFFFFFFBFFFFF; - y = 64'h43DFFC7AA40EA2B0; - z = 64'hC0300080000007FE; - ans = 64'h43DEFC96CEAE34A4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5248483\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC03FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5250497\n"); - end - x = 64'hBCA000000003FFFB; - y = 64'h4010000000000000; - z = 64'h3FDDFFFFFFFFFE00; - ans = 64'h3FDDFFFFFFFFFDF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5252511\n"); - end - x = 64'hBFBFFFFFF00001FF; - y = 64'h3BEFFFFEBFFFFFFE; - z = 64'h47E0020000003FFF; - ans = 64'h47E0020000003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5254525\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'h4340000000000001; - z = 64'hBFF0000000000001; - ans = 64'hC370000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5256539\n"); - end - x = 64'hA87FFFFFF0001000; - y = 64'h7FE0000000000000; - z = 64'hC1F003FFFF000000; - ans = 64'hE86FFFFFF0001000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5258553\n"); - end - x = 64'hE388AAEF1804ADFA; - y = 64'h3F8FFFFFFF007FFF; - z = 64'hC05003FFFFFFFEFF; - ans = 64'hE328AAEF173FB92C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5260567\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'h7FF0000000000001; - z = 64'h4340000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5262581\n"); - end - x = 64'h2C073FDF00CBB813; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hBFC0400000001FFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5264595\n"); - end - x = 64'h3FFEFFFEFFFFFFFF; - y = 64'h38100002FFFFFFFE; - z = 64'hB81EFFFF7FFFFFFF; - ans = 64'h36F53FFF3FF08000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5266609\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'h8010000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5268623\n"); - end - x = 64'h41CBFFFFFFFFEFFF; + x = 64'hBCA0000000000001; y = 64'h801FFFFFFFFFFFFE; - z = 64'h3B3FFFFFFFFBFFFF; - ans = 64'h3B3FFFFFFFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5270637\n"); - end - x = 64'hB7FB47A039F47B8F; - y = 64'hC012D33A35DF82B8; - z = 64'h3FC03D9B3C90E530; - ans = 64'h3FC03D9B3C90E530; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5272651\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'hBFD0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5274665\n"); - end - x = 64'hC1C07FFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'h42DB2D4BE861DF6A; - ans = 64'h42DB2D500861DF6A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5276679\n"); - end - x = 64'h41CDFFFFC0000000; - y = 64'hBFBFF87FFFFFFFFE; - z = 64'h41C000000080FFFF; - ans = 64'h41B881C210FE3FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5278693\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'hBFF0000000000000; - z = 64'h3FF0000000000001; - ans = 64'h4021FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5280707\n"); - end - x = 64'h41DFFA0EFC62A2B5; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'hFFFFC000000FFFFE; - ans = 64'hFFFFC000000FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5282721\n"); - end - x = 64'hA6EF808000000000; - y = 64'hC3F97BC58770EB17; - z = 64'hC1E020001FFFFFFE; - ans = 64'hC1E020001FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5284735\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5286749\n"); - end - x = 64'h3FE000000040003F; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h3C7FFC01FFFFFFFF; - ans = 64'hC01000000040003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5288763\n"); - end - x = 64'h480FFC07FFFFFFFE; - y = 64'h3C000000001FFFEF; - z = 64'hBFBFFF0007FFFFFF; - ans = 64'h441FFC08003FF7EC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5290777\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5292791\n"); - end - x = 64'h002DFFFEFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'h3FFFFFFFFFFFFBFC; - ans = 64'hC029FFFF0000007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5294805\n"); - end - x = 64'h3FE8080000000000; - y = 64'hB677FFDFFFFFFFFE; - z = 64'h801FFFFFFFFFFFD8; - ans = 64'hB67205E7F7FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5296819\n"); - end - x = 64'hC01FFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5298833\n"); - end - x = 64'hBFC75F2E65F71048; - y = 64'h0000000000000001; - z = 64'h400FFFFFFFFFFDFE; - ans = 64'h400FFFFFFFFFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5300847\n"); - end - x = 64'hC383F50A0CB6ED42; - y = 64'h41EB3DD4A3B7B79C; - z = 64'hC189841022924E71; - ans = 64'hC580FD50335FE825; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5302861\n"); - end - x = 64'hC340000000000000; - y = 64'h001FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5304875\n"); - end - x = 64'hAB6FFFFFFFEBFFFF; - y = 64'h3CA0000000000001; - z = 64'h4027FFF000000000; - ans = 64'h4027FFF000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5306889\n"); - end - x = 64'h43E0FDBF1FC3A391; - y = 64'h3FEFFFDFFFFFFFFD; - z = 64'h7FF01F0D90902767; - ans = 64'h7FF81F0D90902767; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5308903\n"); - end - x = 64'hC340000000000000; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h4330000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5310917\n"); - end - x = 64'hBCAFFFC0001FFFFE; - y = 64'h3FE0000000000000; - z = 64'hBFC000400000000F; - ans = 64'hBFC0004000000013; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5312931\n"); - end - x = 64'h3B400000000101FF; - y = 64'h3F301000000FFFFF; - z = 64'h3FE000040003FFFE; - ans = 64'h3FE000040003FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5314945\n"); - end - x = 64'hC340000000000000; - y = 64'h3FF0000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5316959\n"); - end - x = 64'hC1FFFFFFFFFF3FFE; - y = 64'h4000000000000000; - z = 64'h802FE01FFFFFFFFF; - ans = 64'hC20FFFFFFFFF3FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5318973\n"); - end - x = 64'hC030001FFFFEFFFF; - y = 64'hBE800000007FBFFF; - z = 64'hD16000000006FFFF; - ans = 64'hD16000000006FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5320987\n"); - end - x = 64'hC340000000000000; - y = 64'h4010000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC360000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5323001\n"); - end - x = 64'h20E800000000003F; - y = 64'h4340000000000000; - z = 64'hFFDB256EE305E7EE; - ans = 64'hFFDB256EE305E7EE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5325015\n"); - end - x = 64'h7BFFF8003FFFFFFE; - y = 64'h1FB0000000000BFF; - z = 64'hBFB0000060000000; - ans = 64'h5BBFF800400017F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5327029\n"); - end - x = 64'hC340000000000000; - y = 64'h7FE0000000000001; - z = 64'h3FF0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5329043\n"); - end - x = 64'h43F4063A60BE557D; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'h401D88A3C8A4CC8C; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5331057\n"); - end - x = 64'h3FCFFFFFFEFFFFEF; - y = 64'h37F8C27C91B78B6B; - z = 64'hC780000001EFFFFE; - ans = 64'hC780000001EFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5333071\n"); - end - x = 64'hC340000000000000; - y = 64'h8000000000000000; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5335085\n"); - end - x = 64'h257E2D1C6CE4BD4E; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h43D3EC126AA24CBC; - ans = 64'h43D3EC126AA24CBC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5337099\n"); - end - x = 64'h47F24F55280F21A5; - y = 64'hC1D2E757751DE923; - z = 64'hBC76E5E152B15135; - ans = 64'hC9D5A1FD3FE8C36C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5339113\n"); - end - x = 64'hC340000000000000; - y = 64'hBCA0000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5341127\n"); - end - x = 64'h43F017FFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'hC01EFFFFFFFFEFFF; - ans = 64'hC0B01FBFFFFFFFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5343141\n"); - end - x = 64'hBF9B000000000000; - y = 64'h37EFFFFFFEFFF7FF; - z = 64'h3BDFFF8000000FFF; - ans = 64'h3BDFFF8000000FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5345155\n"); - end - x = 64'hC340000000000000; - y = 64'hBFE0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h4330000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5347169\n"); - end - x = 64'h4128574D5C8F3538; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hC3EBFD9EE3D633DB; - ans = 64'hC3EBFD9EE3D63560; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5349183\n"); - end - x = 64'hBFDFF70000000000; - y = 64'h361C00000000003F; - z = 64'h400FFFFFBBFFFFFF; - ans = 64'h400FFFFFBBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5351197\n"); - end - x = 64'hC340000000000000; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'h434FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5353211\n"); - end - x = 64'hC02FFFFFFFC0000F; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'h43F03BFFFFFFFFFF; - ans = 64'h43F03BFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5355225\n"); - end - x = 64'h47FFF6FFFFFFFFFF; - y = 64'hC00000010000003F; - z = 64'hC3F00000000BFFFF; - ans = 64'hC80FF701FF70007D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5357239\n"); - end - x = 64'hC340000000000000; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4371FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5359253\n"); - end - x = 64'hB7F010000FFFFFFF; - y = 64'hC340000000000001; - z = 64'hB336E0808B4E505D; - ans = 64'h3B40100010000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5361267\n"); - end - x = 64'h4DF000001FFFFDFF; - y = 64'hC010010000000003; - z = 64'h41BFFC00000001FF; - ans = 64'hCE1001002001FE02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5363281\n"); - end - x = 64'hC340000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5365295\n"); - end - x = 64'h3FB00007FFFFFFF7; - y = 64'hFFF0000000000001; - z = 64'hC3CE7914194C95AE; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5367309\n"); - end - x = 64'hC6DFBFFFFFFE0000; - y = 64'h43F01FFFFFFFBFFE; - z = 64'h303FFF7FFFDFFFFF; - ans = 64'hCADFFF7FFFFD7CFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5369323\n"); - end - x = 64'hC340000000000001; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5371337\n"); - end - x = 64'h3FBAC24425DCBA63; - y = 64'h0010000000000001; - z = 64'h41E90A03C7D2CD15; - ans = 64'h41E90A03C7D2CD15; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5373351\n"); - end - x = 64'h434FFC0020000000; - y = 64'h4780203FFFFFFFFF; - z = 64'hC02FFFFE000001FF; - ans = 64'h4AE01E3C08203FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5375365\n"); - end - x = 64'hC340000000000001; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5377379\n"); - end - x = 64'hBFC000000007FFFC; - y = 64'h3FD0000000000000; - z = 64'hC50000FFFF000000; - ans = 64'hC50000FFFF000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5379393\n"); - end - x = 64'h3A1001F800000000; - y = 64'h2CD2000000000007; - z = 64'hBFBCEA2C8D11FAEE; - ans = 64'hBFBCEA2C8D11FAEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5381407\n"); - end - x = 64'hC340000000000001; - y = 64'h3FE0000000000001; - z = 64'hC340000000000000; - ans = 64'hC348000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5383421\n"); - end - x = 64'hB062599EFD2E8D66; - y = 64'h3FF0000000000000; - z = 64'hBFFFFFFFFC000002; - ans = 64'hBFFFFFFFFC000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5385435\n"); - end - x = 64'h4030000000030000; - y = 64'hBFC0003FFFFE0000; - z = 64'h358FFFFFFFD00000; - ans = 64'hC00000400001000C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5387449\n"); - end - x = 64'hC340000000000001; - y = 64'h4000000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5389463\n"); - end - x = 64'hBFF0589B0B9001F8; - y = 64'h4010000000000000; - z = 64'h43E0FFFFFFFFC000; - ans = 64'h43E0FFFFFFFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5391477\n"); - end - x = 64'h3F5FFFBBFFFFFFFF; - y = 64'hC7CF9FFFFFFFFFFE; - z = 64'hC3D03FFFFFFFFFEE; - ans = 64'hC73F9FBCCBFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5393491\n"); - end - x = 64'hC340000000000001; - y = 64'h4340000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC690000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5395505\n"); - end - x = 64'hBF9FFFFFFFFFFF01; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hBE5FFFFE0001FFFE; - ans = 64'hC2FFFFFFFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5397519\n"); - end - x = 64'hBF9DFFFFBFFFFFFF; - y = 64'hBFD004000000FFFE; - z = 64'hB812B42897CAD968; - ans = 64'h3F7E077FBFF1DFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5399533\n"); - end - x = 64'hC340000000000001; - y = 64'h7FF0000000000000; - z = 64'hBFF0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5401547\n"); - end - x = 64'hC34FFFFFFFFFFEFF; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'h3FD332C76836F8C2; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5403561\n"); - end - x = 64'h381FFFFFEFFFFFBF; - y = 64'hCF4FFFFFFFFFFF02; - z = 64'hFFDFFFFFDFFE0000; - ans = 64'hFFDFFFFFDFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5405575\n"); - end - x = 64'hC340000000000001; - y = 64'h8010000000000000; - z = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5407589\n"); - end - x = 64'hC0A3E45119503FAD; - y = 64'h801FFFFFFFFFFFFF; - z = 64'hB7FFFFC07FFFFFFF; - ans = 64'hB7FFFFC07FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5409603\n"); - end - x = 64'h3F5000000040001F; - y = 64'hB60FFFFFFFBFF7FF; - z = 64'hBE0004000000001F; - ans = 64'hBE0004000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5411617\n"); - end - x = 64'hC340000000000001; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5413631\n"); - end - x = 64'hC15622341AA51F9D; - y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hC8000040000FFFFF; - ans = 64'hC8000040000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5415645\n"); - end - x = 64'h47E00FFFF0000000; - y = 64'hC7E6114761B264AF; - z = 64'hB80010FFFFFFFFFF; - ans = 64'hCFD627589302CFB2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5417659\n"); - end - x = 64'hC340000000000001; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5419673\n"); - end - x = 64'hBFAFFD7FFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - z = 64'h402FFFF400000000; - ans = 64'h40301FF780000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5421687\n"); - end - x = 64'h43E03FFFFFFEFFFE; - y = 64'hA51FFFFFFD000000; - z = 64'h41EFFFFFFF00FFFF; - ans = 64'h41EFFFFFFF00FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5423701\n"); - end - x = 64'hC340000000000001; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h4360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5425715\n"); - end - x = 64'hC1D4FFFFFFFFFFFF; - y = 64'hC010000000000001; - z = 64'hB2700003DFFFFFFF; - ans = 64'h41F5000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5427729\n"); - end - x = 64'hB800007FFFFE0000; - y = 64'hFFFFFFFFFFFE7FFE; - z = 64'h7FF4000002000000; - ans = 64'hFFFFFFFFFFFE7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5429743\n"); - end - x = 64'hC340000000000001; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'h46A0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5431757\n"); - end - x = 64'h3DC0007FFFFFFEFE; - y = 64'hFFE0000000000001; - z = 64'h480AECB2641E1823; - ans = 64'hFDB0007FFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5433771\n"); - end - x = 64'h3801FFFFFFE00000; - y = 64'h3FEFFFFEBFFFFFFF; - z = 64'hC342907ED9EA6975; - ans = 64'hC342907ED9EA6975; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5435785\n"); - end - x = 64'hC340000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5437799\n"); - end - x = 64'hBF924DEDD9119EE1; - y = 64'h0000000000000001; - z = 64'h2710000200000400; - ans = 64'h2710000200000400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5439813\n"); - end - x = 64'hC002D684016B6C55; - y = 64'h33AFFFFFF0800000; - z = 64'h403FBDBE67E4A6F0; - ans = 64'h403FBDBE67E4A6F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5441827\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5443841\n"); - end - x = 64'h801080000003FFFF; - y = 64'h3CA0000000000000; - z = 64'h4A6A29989E485F05; - ans = 64'h4A6A29989E485F05; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5445855\n"); - end - x = 64'h57A00000087FFFFF; - y = 64'hDAA1F96B0221DB2F; - z = 64'h4000200000000100; - ans = 64'hF251F96B0BAE5C07; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5447869\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'h3FD0000000000001; - z = 64'hBFF0000000000001; - ans = 64'hC330000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5449883\n"); - end - x = 64'hB70FFFFFFFFFFFF2; - y = 64'h3FE0000000000000; - z = 64'hCDF0000000100000; - ans = 64'hCDF0000000100000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5451897\n"); - end - x = 64'h420FFFFFFFFFFFFA; - y = 64'hC3C0004000001FFF; - z = 64'hBFCBFFFFFFFFFF7F; - ans = 64'hC5E0004000001FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5453911\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'h3FF0000000000001; - z = 64'h4340000000000000; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5455925\n"); - end - x = 64'h92E00000007FFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'h4AAFFFFFFC001FFF; - ans = 64'h4AAFFFFFFC001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5457939\n"); - end - x = 64'hC03000003FFDFFFF; - y = 64'h4034000000000002; - z = 64'h3FB0100000001000; - ans = 64'hC073FEFF4FFD8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5459953\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'h4010000000000000; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5461967\n"); - end - x = 64'h41F003FFFFF00000; - y = 64'h401FFFFFFFFFFFFE; - z = 64'hCEA000007BFFFFFF; - ans = 64'hCEA000007BFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5463981\n"); - end - x = 64'h41DFFFFFFFFFFEFB; - y = 64'hBFEFFC0000000040; - z = 64'h41C07FFC00000000; - ans = 64'hC1D7BC01FFFFFF3B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5465995\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'h7FE0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5468009\n"); - end - x = 64'hC1DADF799416E178; - y = 64'h7FEFFFFFFFFFFFFE; - z = 64'h3F901FFFFFFFBFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5470023\n"); - end - x = 64'h4ACFFFFFFFE07FFF; - y = 64'h380111A0C92FBEE3; - z = 64'hBFC020EB7964E9DF; - ans = 64'h42E111A0C91EF184; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5472037\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'h8000000000000000; - z = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5474051\n"); - end - x = 64'hC09000003FFFC000; - y = 64'h800FFFFFFFFFFFFF; - z = 64'hC2BFFFFFFEFFFDFE; - ans = 64'hC2BFFFFFFEFFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5476065\n"); - end - x = 64'hC3CC3FFFFFFFFFFF; - y = 64'h00200020000FFFFE; - z = 64'hC0B0E150163A077C; - ans = 64'hC0B0E150163A077C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5478079\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - z = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5480093\n"); - end - x = 64'h59500000001FFEFE; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'h403BD6EEEFC0903B; - ans = 64'hD6100000001FFEFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5482107\n"); - end - x = 64'h000FFFFFFFFFFC00; - y = 64'h4030400040000000; - z = 64'h4033FFFFFFFE0000; - ans = 64'h4033FFFFFFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5484121\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5486135\n"); - end - x = 64'hC1EFFFFFFFFC0003; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'h41DF7FFFFFFFFBFF; - ans = 64'h41F7DFFFFFFDFF01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5488149\n"); - end - x = 64'hC3EFFBFFFFFFFFDF; - y = 64'h403FFBFFFFFFFFFE; - z = 64'h380FFFFFFFFFFFE3; - ans = 64'hC43FF8007FFFFFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5490163\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h435FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5492177\n"); - end - x = 64'h4F8000000000083F; - y = 64'hC000000000000001; - z = 64'hBF49221D94699EAF; - ans = 64'hCF90000000000840; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5494191\n"); - end - x = 64'hC1E0000000009FFE; - y = 64'h43D00003FFFDFFFF; - z = 64'hC0346183422D9835; - ans = 64'hC5C00003FFFE9FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5496205\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'h437FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5498219\n"); - end - x = 64'h7FD0000800002000; - y = 64'hC340000000000001; - z = 64'hC98FFFFFFF9FFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5500233\n"); - end - x = 64'hBF5FFDFEFFFFFFFF; - y = 64'hC1C00000000007FE; - z = 64'hC068F8E52E02B635; - ans = 64'h412FFC6F71AD2FCF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5502247\n"); - end - x = 64'hC34FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5504261\n"); - end - x = 64'h3FDEFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - z = 64'h00021FFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5506275\n"); - end - x = 64'h43C00000000C0000; - y = 64'h3BA03FFFFFFFEFFE; - z = 64'hC19E0000000001FE; - ans = 64'hC19DFFFFFFFBF1FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5508289\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'h0000000000000001; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5510303\n"); - end - x = 64'h800FFFFFFFFFFF00; - y = 64'h0010000000000000; - z = 64'hC0D00000C0000000; - ans = 64'hC0D00000C0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5512317\n"); - end - x = 64'hB81EFFFFFFFFF7FF; - y = 64'h448FFFFFFF000007; - z = 64'h37FBCF34905D0CA7; - ans = 64'hBCBEFFFFFF07F806; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5514331\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'h3CA0000000000001; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5516345\n"); - end - x = 64'hB80686567ADB6535; - y = 64'h3FD0000000000000; - z = 64'h402FFFFFFDFE0000; - ans = 64'h402FFFFFFDFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5518359\n"); - end - x = 64'hC00595EBD72B467C; - y = 64'h43CF77FFFFFFFFFE; - z = 64'hC1E9531CB30BC1E8; - ans = 64'hC3E53A2EACF221AC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5520373\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'h3FE0000000000001; - z = 64'h3FF0000000000001; - ans = 64'hC33FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5522387\n"); - end - x = 64'hC07FFBFFFFFFEFFF; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h43DEFFFFFF7FFFFE; - ans = 64'h43DEFFFFFF7FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5524401\n"); - end - x = 64'hACFE3D603199179F; - y = 64'h4A90FFFFFFFFC000; - z = 64'h7FFC0005BF1C67B6; - ans = 64'h7FFC0005BF1C67B6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5526415\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'h4000000000000000; - z = 64'hC340000000000000; - ans = 64'hC363FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5528429\n"); - end - x = 64'h3FA7FFFFFFE00000; - y = 64'h400FFFFFFFFFFFFE; - z = 64'h447FFFFFFFFFFFB6; - ans = 64'h447FFFFFFFFFFFB6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5530443\n"); - end - x = 64'hC01FFFF000001FFE; - y = 64'h419FFFBFFFFFFFFF; - z = 64'h4020088000000000; - ans = 64'hC1CFFFAFFC1DFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5532457\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'h4340000000000000; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5534471\n"); - end - x = 64'h43EB0FE627379F92; - y = 64'h434FFFFFFFFFFFFE; - z = 64'h41FEFFFFFFFEFFFF; - ans = 64'h474B0FE627379F90; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5536485\n"); - end - x = 64'h3F00000003FF7FFF; - y = 64'h486FFFC01FFFFFFF; - z = 64'hC1D0000007FFFFFD; - ans = 64'h477FFFC027FEF007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5538499\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'h7FF0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5540513\n"); - end - x = 64'h3FE300359974A384; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'h3F9B3495A3BE0D09; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5542527\n"); - end - x = 64'hBF2FFFFC007FFFFF; - y = 64'hBFFA3248970AA8DD; - z = 64'hFFFFE0000001FFFE; - ans = 64'hFFFFE0000001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5544541\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - z = 64'hBFF0000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5546555\n"); - end - x = 64'h3FBFF0FFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFF; - z = 64'hC3D040000000000F; - ans = 64'hC3D040000000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5548569\n"); - end - x = 64'hC3CDFFFFFFF7FFFF; - y = 64'hB805C95BB6EC1A60; - z = 64'hB7FAA09582D44A39; - ans = 64'h3BE46CC5FB77E662; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5550583\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - z = 64'h4340000000000000; - ans = 64'h4340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5552597\n"); - end - x = 64'h3FF221640E87BBAD; - y = 64'hBFD0000000000001; - z = 64'hC1D70A764CFA4319; - ans = 64'hC1D70A764D0C647D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5554611\n"); - end - x = 64'h454FC00000000000; - y = 64'h406FE000000001FF; - z = 64'h41DF00000000FFFF; - ans = 64'h45CFA040000001FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5556625\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5558639\n"); - end - x = 64'h3FFFFFFFFFFFF780; - y = 64'hBFF0000000000001; - z = 64'h400CFEFB818713C9; - ans = 64'h3FF9FDF7030E3010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5560653\n"); - end - x = 64'hB80000000FFFFBFF; - y = 64'hFFEBC1EF4E485592; - z = 64'h42E2000800000000; - ans = 64'h77FBC1EF6A0A3DEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5562667\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h436FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5564681\n"); - end - x = 64'h37EFFFBFFBFFFFFE; - y = 64'hC010000000000001; - z = 64'h426FFFCFFFFFFFFF; - ans = 64'h426FFFCFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5566695\n"); - end - x = 64'hC3C7979FC93CF795; - y = 64'hC01FFFFDFFEFFFFF; - z = 64'hC72FFFDFFFFFBFFF; - ans = 64'hC72FFFDFFFFFBFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5568709\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - ans = 64'h46AFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5570723\n"); - end - x = 64'hB7F70C049E6A16AF; - y = 64'hFFE0000000000000; - z = 64'hC02FFFFE7FFFFFFF; - ans = 64'h77E70C049E6A16AF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5572737\n"); - end - x = 64'hBF76A55146618FF8; - y = 64'hC2C000001FFFBFFE; - z = 64'h3FE000BFFFFFFFFE; - ans = 64'h4246A55173AC17F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5574751\n"); - end - x = 64'hC34FFFFFFFFFFFFE; - y = 64'hFFF0000000000001; - z = 64'hC340000000000000; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5576765\n"); - end - x = 64'hC1E0000000100010; - y = 64'h0000000000000000; - z = 64'h3F9FFDFFDFFFFFFF; - ans = 64'h3F9FFDFFDFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5578779\n"); - end - x = 64'h40300000000023FE; - y = 64'h2212E1863EB8D556; - z = 64'h47EFE80D508843B7; - ans = 64'h47EFE80D508843B7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5580793\n"); - end - x = 64'hFFE0000000000000; - y = 64'h0010000000000001; - z = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5582807\n"); - end - x = 64'hB051E706CE9D287D; - y = 64'h3CA0000000000000; - z = 64'h401FFFF7FFFFC000; - ans = 64'h401FFFF7FFFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5584821\n"); - end - x = 64'h43FFFFFFFFFFFF1F; - y = 64'hC7E1DD24871F44A6; - z = 64'h431DBB153CF092B9; - ans = 64'hCBF1DD24871F4428; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5586835\n"); - end - x = 64'hFFE0000000000000; - y = 64'h3FD0000000000001; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFC0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5588849\n"); - end - x = 64'h095FFFEFFFFFEFFE; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'hB85664DBD796F697; - ans = 64'hB85664DBD796F697; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5590863\n"); - end - x = 64'h48F1000000200000; - y = 64'h404D000000000000; - z = 64'h41EAB80D34FBD97A; - ans = 64'h494ED000003A0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5592877\n"); - end - x = 64'hFFE0000000000000; - y = 64'h3FF0000000000000; - z = 64'hBFF0000000000001; + z = 64'hFFE0000000000000; ans = 64'hFFE0000000000000; rn = 1; rz = 0; @@ -130603,12 +286408,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5594891\n"); + $fwrite(fp,"3741101\n"); end - x = 64'h40D4374FA828B57A; - y = 64'h3FFFFFFFFFFFFFFE; - z = 64'hB08008000000000F; - ans = 64'h40E4374FA828B579; + x = 64'h3FE00001FFFC0000; + y = 64'h3FCB2596D8FD2EB9; + z = 64'hBFE0000000000001; + ans = 64'hBFD936997095AFE5; rn = 1; rz = 0; rm = 0; @@ -130650,529 +286455,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5596905\n"); + $fwrite(fp,"3741715\n"); end - x = 64'hBFFFFC00000001FE; - y = 64'hBE600000080FFFFE; - z = 64'h41FFFFFFFFFFF804; - ans = 64'h41FFFFFFFFFFF804; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5598919\n"); - end - x = 64'hFFE0000000000000; - y = 64'h4010000000000000; - z = 64'h4340000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5600933\n"); - end - x = 64'hBDCE895D0278844A; - y = 64'h401FFFFFFFFFFFFF; - z = 64'h3810DF2445F89E39; - ans = 64'hBDFE895D02788449; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5602947\n"); - end - x = 64'h3F98000000000800; - y = 64'h401FFFFFFFEFFEFE; - z = 64'hB7EFFFFE7FFFFFFF; - ans = 64'h3FC7FFFFFFF4073E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5604961\n"); - end - x = 64'hFFE0000000000000; - y = 64'h434FFFFFFFFFFFFE; - z = 64'hFFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5606975\n"); - end - x = 64'h3CA00000005FFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h7FE0043FFFFFFFFF; - ans = 64'h7FE0044000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5608989\n"); - end - x = 64'hBE10000000080010; - y = 64'h41E00000003FFBFF; - z = 64'h3EA954E801D58ACC; - ans = 64'hBFFFFFFF35E8B80F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5611003\n"); - end - x = 64'hFFE0000000000000; - y = 64'h7FFFFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5613017\n"); - end - x = 64'hBD200003FFF7FFFE; - y = 64'h800FFFFFFFFFFFFF; - z = 64'h3F3BFFFFFFFFFFEE; - ans = 64'h3F3BFFFFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5615031\n"); - end - x = 64'hB70FFFFFEFFFFF7F; - y = 64'hC03C206056154C17; - z = 64'h3E007E0000000000; - ans = 64'h3E007E0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5617045\n"); - end - x = 64'hFFE0000000000000; - y = 64'h801FFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - ans = 64'h4013FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5619059\n"); - end - x = 64'h40300000000000FF; + x = 64'hBCA0000000000001; y = 64'hBCA0000000000001; - z = 64'hC05FFFFFF7FFFFEE; - ans = 64'hC05FFFFFF7FFFFEE; + z = 64'h4073FFFFEFFFFFFE; + ans = 64'h4073FFFFEFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -131214,12 +286502,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5621073\n"); + $fwrite(fp,"3742329\n"); end - x = 64'h404FFFFFFFFDFFF7; - y = 64'h381FFFFFDFFFFFE0; - z = 64'hC1C00FFFFFFFFBFF; - ans = 64'hC1C00FFFFFFFFBFF; + x = 64'hD2F0B2C9A70221FF; + y = 64'h43E199DDC5665EB1; + z = 64'hFFE84B6CAA717C29; + ans = 64'hFFE84B6CAA717C29; rn = 1; rz = 0; rm = 0; @@ -131261,12 +286549,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5623087\n"); + $fwrite(fp,"3742943\n"); end - x = 64'hFFE0000000000000; + x = 64'hD94FF81000000000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h0000000000000001; + ans = 64'h560FF80FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3743557\n"); + end + x = 64'hBCA0000000000001; + y = 64'h400FFFFFF7FFFDFF; + z = 64'hB4DFEFFFFFFFFF7F; + ans = 64'hBCBFFFFFF7FFFE01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3744171\n"); + end + x = 64'hC52FFEFFFFFFBFFE; + y = 64'hBFD0000000000000; + z = 64'hBFA0000FFFFFFE00; + ans = 64'h450FFEFFFFFFBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3744785\n"); + end + x = 64'hBCA0000000000001; + y = 64'hBFFB106850049EF2; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3745399\n"); + end + x = 64'h43429BCA2DC4DCB8; + y = 64'h29FDFFFFFFFFF800; + z = 64'h4340200080000000; + ans = 64'h4340200080000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3746013\n"); + end + x = 64'hBCA0000000000001; y = 64'hBFDFFFFFFFFFFFFF; - z = 64'hC340000000000000; - ans = 64'h7FCFFFFFFFFFFFFF; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; rn = 1; rz = 0; rm = 0; @@ -131308,12 +286831,153 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5625101\n"); + $fwrite(fp,"3746627\n"); end - x = 64'h00D10000FFFFFFFE; + x = 64'hC250FFFFFFFFFFFE; + y = 64'hC14A4CD328768347; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'h43ABF1A05AFDEB78; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3747241\n"); + end + x = 64'hBCA0000000000001; + y = 64'hBFE0000000000000; + z = 64'h480FC01FFFFFFFFF; + ans = 64'h480FC01FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3747855\n"); + end + x = 64'h3FD200000001FFFF; + y = 64'h3F80000400800000; + z = 64'hB810FFFFFFFFFFFC; + ans = 64'h3F62000480920000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3748469\n"); + end + x = 64'hB810100000000000; y = 64'hBFE0000000000001; - z = 64'h400FF801FFFFFFFF; - ans = 64'h400FF801FFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -131355,12 +287019,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5627115\n"); + $fwrite(fp,"3749083\n"); end - x = 64'h3F8FFFDFFFFFF7FF; - y = 64'hBFDFFFE0000FFFFE; - z = 64'hBFC00000002007FF; - ans = 64'hBFC0FFFE002187BE; + x = 64'hBCA0000000000001; + y = 64'h41DFFFFFFFFF0003; + z = 64'h3CA0001FFFFFFFFB; + ans = 64'hBE8FFFFFFFBEFF85; rn = 1; rz = 0; rm = 0; @@ -131402,10 +287066,1890 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5629129\n"); + $fwrite(fp,"3749697\n"); end - x = 64'hFFE0000000000000; - y = 64'hBFFFFFFFFFFFFFFF; + x = 64'hFFF20001FFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBFBBFFFFFFFFFBFF; + ans = 64'hFFFA0001FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3750311\n"); + end + x = 64'hBCA0000000000001; + y = 64'hBCAFF00003FFFFFF; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3750925\n"); + end + x = 64'h43DFFFFFFF7FFFC0; + y = 64'h231F2EC23DED0C48; + z = 64'h518EFFFFC0000000; + ans = 64'h518EFFFFC0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3751539\n"); + end + x = 64'hBCA0000000000001; + y = 64'hBFF0000000000001; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3752153\n"); + end + x = 64'hC08FFFFEE0000000; + y = 64'h43FE83C87C2780E4; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hC49E83C769857487; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3752767\n"); + end + x = 64'hBCA0000000000001; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBFE90AAFA45FC660; + ans = 64'hBFE90AAFA45FC65E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3753381\n"); + end + x = 64'hC1F97E13BBA0D54D; + y = 64'h434FFF80000000FF; + z = 64'h41E200003FFFFFFF; + ans = 64'hC5597DADC351E795; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3753995\n"); + end + x = 64'h3FC3FF7FFFFFFFFF; + y = 64'hC000000000000000; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3754609\n"); + end + x = 64'hBCA0000000000001; + y = 64'h41E00000000000FD; + z = 64'h748FFFFFFDF7FFFF; + ans = 64'h748FFFFFFDF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3755223\n"); + end + x = 64'h37FBBEB4E97ED446; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h7FE9E49884FB358B; + ans = 64'h7FE9E49884FB358B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3755837\n"); + end + x = 64'hBCA0000000000001; + y = 64'hC7FFFFFFF0001FFF; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h44AFFFFFF0002001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3756451\n"); + end + x = 64'hC3E000000207FFFF; + y = 64'h3FE0000000004003; + z = 64'hC1D200000000000F; + ans = 64'hC3D00000021A4002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3757065\n"); + end + x = 64'hBCA0000000000001; + y = 64'hC010000000000000; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hC00FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3757679\n"); + end + x = 64'hC1E000000000DFFF; + y = 64'h47EFFFE7FFFFFFFF; + z = 64'hBCA0000000000000; + ans = 64'hC9DFFFE80001BFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3758293\n"); + end + x = 64'hBCA0000000000001; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hC180000000001003; + ans = 64'hC180000000001003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3758907\n"); + end + x = 64'h3F20407FFFFFFFFF; + y = 64'hFFD01FFFFFFFFFFE; + z = 64'hC1DFFFFFFE00001F; + ans = 64'hFF006100FFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3759521\n"); + end + x = 64'h3AD0000000001FDF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3760135\n"); + end + x = 64'hBCA0000000000001; + y = 64'hC1D0000FFFFFFFFD; + z = 64'h001022851DC3F35C; + ans = 64'h3E80000FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3760749\n"); + end + x = 64'hB7EFFFFFFDFFFFE0; + y = 64'hC340000000000001; + z = 64'h43F103FFFFFFFFFE; + ans = 64'h43F103FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3761363\n"); + end + x = 64'hBCA0000000000001; + y = 64'hC80C020548AB0BD7; + z = 64'h3FF0000000000000; + ans = 64'h44BC020548AB0BD9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3761977\n"); + end + x = 64'h8A7EFFFFFFFFFFF7; + y = 64'h42620001FFFFFFFF; + z = 64'hC1D000001000FFFE; + ans = 64'hC1D000001000FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3762591\n"); + end + x = 64'hBCA0000000000001; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hC000000000000000; + ans = 64'hB980000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3763205\n"); + end + x = 64'h7FFFFE00003FFFFE; + y = 64'h3FB0000000107FFE; + z = 64'h8010000000000001; + ans = 64'h7FFFFE00003FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3763819\n"); + end + x = 64'hBCA0000000000001; + y = 64'hFFE0000000000001; + z = 64'h47EF19603D95F25F; + ans = 64'h7C90000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3764433\n"); + end + x = 64'h434FC6B058E8DB04; + y = 64'hC7F0001F7FFFFFFE; + z = 64'h09BFFFFFFFFEFEFF; + ans = 64'hCB4FC6EEE8140A0A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3765047\n"); + end + x = 64'hBD2000107FFFFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hC340000000000001; + ans = 64'h7D2000107FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3765661\n"); + end + x = 64'hBCA0000000000001; + y = 64'h7FDFFFFFFFFFEFDF; + z = 64'hC00FFF01FFFFFFFE; + ans = 64'hFC8FFFFFFFFFEFE1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3766275\n"); + end + x = 64'hC1EFF8000000000F; + y = 64'hFFF0000000000000; + z = 64'h403E18E7F4D1673B; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3766889\n"); + end + x = 64'hBCA0000000000001; + y = 64'h5D80000001003FFF; + z = 64'h3FE0000000000001; + ans = 64'hDA30000001004000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3767503\n"); + end + x = 64'h7FE433DE65AD5CF1; + y = 64'hBFB00000004001FF; + z = 64'h7FF0000008000001; + ans = 64'h7FF8000008000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3768117\n"); + end + x = 64'hBCA0000000000001; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3768731\n"); + end + x = 64'hFE4FF0FFFFFFFFFE; + y = 64'hBCA0000040003FFE; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h7AFFF1007FC47FBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3769345\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h0000000000000000; + z = 64'hC3CFEFFF7FFFFFFF; + ans = 64'hC3CFEFFF7FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3769959\n"); + end + x = 64'hC02000003FFFFFFE; + y = 64'h05300005FFFFFFFF; + z = 64'hC0810000007FFFFE; + ans = 64'hC0810000007FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3770573\n"); + end + x = 64'hC01FFE00000001FF; + y = 64'h0000000000000001; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3771187\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hDADFFFFFFFFFFFF8; + z = 64'hC3CFDFFFFFFBFFFF; + ans = 64'h579FFFFFFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3771801\n"); + end + x = 64'h0020000000002080; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3F0FFFFFFC080000; + ans = 64'h3F0FFFFFFC080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3772415\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC7F0000000001FFC; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h44B0000000001FFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3773029\n"); + end + x = 64'hC3F4695058A6C40E; + y = 64'h4040080000000000; + z = 64'hB83FFFFDFFFFFFBE; + ans = 64'hC444738500D31770; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3773643\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h0010000000000001; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3774257\n"); + end + x = 64'hC1F00000077FFFFE; + y = 64'hAB2000800000007F; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -131449,12 +288993,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5631143\n"); + $fwrite(fp,"3774871\n"); end - x = 64'h81E0000000FFF800; - y = 64'hC000000000000001; - z = 64'h7FD01FFDFFFFFFFF; - ans = 64'h7FD01FFDFFFFFFFF; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hFFF3EC28CD007481; + ans = 64'hFFFBEC28CD007481; rn = 1; rz = 0; rm = 0; @@ -131496,12 +289040,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5633157\n"); + $fwrite(fp,"3775485\n"); end - x = 64'hCA20000000000004; - y = 64'h434FFC00000003FE; - z = 64'h30CFFFFFFFFFEFFE; - ans = 64'hCD7FFC0000000406; + x = 64'h3FFC94ABE6867525; + y = 64'hC67E87B31ABFDBF0; + z = 64'h4012000FFFFFFFFF; + ans = 64'hC68B449454D84E0E; rn = 1; rz = 0; rm = 0; @@ -131543,11 +289087,293 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5635171\n"); + $fwrite(fp,"3776099\n"); end - x = 64'hFFE0000000000000; - y = 64'hC01FFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; + x = 64'hFFD6F486F2DE1EE8; + y = 64'h3CA0000000000000; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'hFC86F486F2DE1EE8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3776713\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hBFCD146D2EEB9817; + z = 64'h43E00040007FFFFF; + ans = 64'h43E00040007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3777327\n"); + end + x = 64'hC80FF7FFFF7FFFFF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h43FFFFFFFFE001FE; + ans = 64'hC4CFF6FFFF8000FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3777941\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC032000000000004; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CF3000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3778555\n"); + end + x = 64'h4060001FBFFFFFFF; + y = 64'hC00F8CABD8D44234; + z = 64'h342DFF7FFFFFFFFF; + ans = 64'hC07F8CEA73F94477; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3779169\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FD0000000000000; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3779783\n"); + end + x = 64'h402BFFFFFFFFFFFF; + y = 64'hC34F36F54B2B6FAA; + z = 64'h7FF0000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -131590,12 +289416,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5637185\n"); + $fwrite(fp,"3780397\n"); end - x = 64'hBFBFF5FFFFFFFFFF; - y = 64'hC340000000000000; - z = 64'h6E300000007FFBFF; - ans = 64'h6E300000007FFBFF; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hBFBFFFFFF800000E; + ans = 64'hBFBFFFFFF8000016; rn = 1; rz = 0; rm = 0; @@ -131637,12 +289463,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5639199\n"); + $fwrite(fp,"3781011\n"); end - x = 64'hC4708007FFFFFFFF; - y = 64'hB7FFFFFC00004000; - z = 64'hBFFFFFFFFFFFFFF4; - ans = 64'hBFFFFFFFFFFFFFF4; + x = 64'h3FFFEFFFFFFFFFEF; + y = 64'hB7F0000FFC000000; + z = 64'hB73003FFFFFFF000; + ans = 64'hB7FFF1202803FFEE; rn = 1; rz = 0; rm = 0; @@ -131684,12 +289510,435 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5641213\n"); + $fwrite(fp,"3781625\n"); end - x = 64'hFFE0000000000000; - y = 64'hFFE0000000000001; + x = 64'h0023A4E6A0757395; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hC000000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3782239\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FF8E39EA08CCCC9; + z = 64'h3810000000BFFFFF; + ans = 64'hBCB8E39EA08CCCC8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3782853\n"); + end + x = 64'h47DFFFFFFFFFFDBF; + y = 64'h3FE0000000000001; + z = 64'hC3EFFFE000001000; + ans = 64'h47CFFFFFFFFFFDC1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3783467\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hCD9C9445CD63D125; + z = 64'h3CA0000000000000; + ans = 64'h4A5C9445CD63D124; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3784081\n"); + end + x = 64'hC02F7FFFEFFFFFFF; + y = 64'hC03FFBFFFFFFFFEF; + z = 64'hBCAFFFFFFFC3FFFE; + ans = 64'h407F7C0FF001FFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3784695\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hBFD0000000000000; + ans = 64'hBFD0000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3785309\n"); + end + x = 64'hBFFFFFFFFFFF0000; + y = 64'hBFFD7E746AFB16D4; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3785923\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FF0000000000001; + z = 64'h3FB81E1E1999C633; + ans = 64'h3FB81E1E1999C623; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3786537\n"); + end + x = 64'hC7E573ADD2BD9CFF; + y = 64'hBFD0001FFFFFFFDE; + z = 64'h3FD47F130055411E; + ans = 64'h47C573D8BA19424D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3787151\n"); + end + x = 64'h8721FFFFFFEFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; z = 64'hBFF0000000000001; - ans = 64'h7FF0000000000000; + ans = 64'hBFF0000000000001; rn = 1; rz = 0; rm = 0; @@ -131731,12 +289980,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5643227\n"); + $fwrite(fp,"3787765\n"); end - x = 64'hB87FFFF000000002; - y = 64'hFFF0000000000000; - z = 64'h5B5FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FC200001FFFFFFF; + z = 64'h3FDFFFF00000FFFF; + ans = 64'h3FDFFFF00000FFFE; rn = 1; rz = 0; rm = 0; @@ -131778,12 +290027,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5645241\n"); + $fwrite(fp,"3788379\n"); end - x = 64'hFFFFFFFFFFDFFFFB; - y = 64'hCF3FFFFE00000FFF; - z = 64'hBC64B36DB2BB47FA; - ans = 64'hFFFFFFFFFFDFFFFB; + x = 64'h401FFFF80000001E; + y = 64'h4000000000000000; + z = 64'hB7E4881AB2642528; + ans = 64'h402FFFF80000001E; rn = 1; rz = 0; rm = 0; @@ -131825,10 +290074,3065 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5647255\n"); + $fwrite(fp,"3788993\n"); end - x = 64'hFFE0000000000001; - y = 64'h0000000000000001; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FE328C04730D7AB; + z = 64'h0010000000000001; + ans = 64'hBCA328C04730D7AA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3789607\n"); + end + x = 64'h3FC44EB15655CF8C; + y = 64'hBFB001000000000F; + z = 64'hC611C5D9D036DBD6; + ans = 64'hC611C5D9D036DBD6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3790221\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hBCA0000000000001; + ans = 64'hBCD1FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3790835\n"); + end + x = 64'h7FD0000000020FFF; + y = 64'hC087364277477C0D; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3791449\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h4010000000000000; + z = 64'h405FFFFC0000000E; + ans = 64'h405FFFFC0000000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3792063\n"); + end + x = 64'hB80FFFF80000001F; + y = 64'h7FD824F9FC677296; + z = 64'hC1ECDC90E18A4273; + ans = 64'hF7F824F3F328F394; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3792677\n"); + end + x = 64'hBFBFFFFFFFFFFFFF; + y = 64'h4010000000000001; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFF8000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3793291\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h381FFBFFFFFFFF7E; + z = 64'h402FFBFFFFEFFFFF; + ans = 64'h402FFBFFFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3793905\n"); + end + x = 64'h3E8000002FFFFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h401FFFF6FFFFFFFE; + ans = 64'h401FFFF7400000BE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3794519\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h37E7518E920E9CB8; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hB4A7518E920E9CB7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3795133\n"); + end + x = 64'hFFFC634E56F80E2B; + y = 64'hC00FFE00007FFFFE; + z = 64'hC5927F0A4882C3A0; + ans = 64'hFFFC634E56F80E2B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3795747\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h4340000000000001; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3796361\n"); + end + x = 64'h40F8845913A28A1B; + y = 64'h3CAFFF00000007FE; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h4020000000003106; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3796975\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h3FAC643DA383C0B4; + ans = 64'hC00F8E6F0971F0FA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3797589\n"); + end + x = 64'h403FFFFFFFFFFB7F; + y = 64'h37F8000003FFFFFF; + z = 64'h41D020000000007E; + ans = 64'h41D020000000007E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3798203\n"); + end + x = 64'hBE92EA44B97B547E; + y = 64'h7FE0000000000000; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hFE82EA44B97B547E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3798817\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hBE5FFFFFFFFFBFF0; + z = 64'hBFB000000FFFFFBF; + ans = 64'hBFB000000FFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3799431\n"); + end + x = 64'hC1E0000001FDFFFF; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h400BDB005C4DF29B; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3800045\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC3D25C01DBF7A016; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3800659\n"); + end + x = 64'hB7EBFEDEC7BFCAE2; + y = 64'h002C4A674B537A5C; + z = 64'hBB70000018000000; + ans = 64'hBB70000018000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3801273\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h7FF0000000000000; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3801887\n"); + end + x = 64'h403FDFDFFFFFFFFE; + y = 64'h543C00000000007F; + z = 64'h4010000000000000; + ans = 64'h548BE3E40000007D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3802501\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h45B518F9DBC8077E; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3803115\n"); + end + x = 64'h388FFFFFFE001FFE; + y = 64'hB80B0B869627BF01; + z = 64'h40869F3B701EF024; + ans = 64'h40869F3B701EF024; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3803729\n"); + end + x = 64'h403FFFFFFFFE1FFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hBFD0000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3804343\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h002B6C86ECDC9502; + z = 64'h221BE5101396B494; + ans = 64'h221BE5101396B494; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3804957\n"); + end + x = 64'h3F9007FFFFBFFFFE; + y = 64'h8000000000000001; + z = 64'hC04FFFFFFFFFFBFB; + ans = 64'hC04FFFFFFFFFFBFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3805571\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h480FFFFFFFF7F000; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3806185\n"); + end + x = 64'hC3D84640FD57069E; + y = 64'hC6FD409D3113A6A2; + z = 64'hBB5A99581212CBD0; + ans = 64'h4AE630AEA57AE2A1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3806799\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h8000000000000000; + ans = 64'h0000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3807413\n"); + end + x = 64'h3FC4CD0E86115DD9; + y = 64'hC06FFFFFFBFFFFFE; + z = 64'h4000000000000001; + ans = 64'hC043CD0E8377BC07; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3808027\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h8010000000000001; + z = 64'hC0CFFEFFFFFFE000; + ans = 64'hC0CFFEFFFFFFE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3808641\n"); + end + x = 64'h480EFFFFFFFFFFF7; + y = 64'hC027FFFFFFFDFFFF; + z = 64'hC1C3FFE000000000; + ans = 64'hC8473FFFFFFE0FF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3809255\n"); + end + x = 64'h800000000001FFDF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3809869\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h37FFFFFFFFE0000F; + z = 64'h43F8DD02D524E71E; + ans = 64'h43F8DD02D524E71E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3810483\n"); + end + x = 64'h40307FFFFFF7FFFF; + y = 64'hBCA0000000000000; + z = 64'h3FCFFFFFFFFFBFEF; + ans = 64'h3FCFFFFFFFFFBFAD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3811097\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFBDF; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3811711\n"); + end + x = 64'hB82000040000000F; + y = 64'h37FFFFFFE00007FE; + z = 64'h33300001FFFFFEFE; + ans = 64'h33300001FFFFFEEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3812325\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3812939\n"); + end + x = 64'hFFF01FFFFFFFFFDF; + y = 64'h3CA00000005FFFFF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'hFFF81FFFFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3813553\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hBFD0000000000000; + z = 64'hFFDE00000000003F; + ans = 64'hFFDE00000000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3814167\n"); + end + x = 64'hBE26336215FE569D; + y = 64'hC02000000FFFFFFB; + z = 64'hBFC0800000000FFF; + ans = 64'hBFC07FFFD3994BA7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3814781\n"); + end + x = 64'hC1F00000C0000000; + y = 64'hBFD0000000000001; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h41D00000C0000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3815395\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC1D0000020000001; + z = 64'hBF9FFFFFFFF7FFFC; + ans = 64'hBF9FFFEFFFF7DFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3816009\n"); + end + x = 64'hC1C00000003FEFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBFF3FFFFFFFF8000; + ans = 64'h41AFFFFFFDFFDFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3816623\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h43DFC00000000010; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC3500000000001FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3817237\n"); + end + x = 64'h04F0001FFFFFFFFE; + y = 64'h3FBFFFFFFFFFFF1E; + z = 64'h41C003EFFFFFFFFF; + ans = 64'h41C003EFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3817851\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hBFE0000000000001; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3818465\n"); + end + x = 64'h48351C562148E3C3; + y = 64'hC3C0001040000000; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'hCC051C6B92105D91; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3819079\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h357FFFFFFFC00002; + ans = 64'h3CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3819693\n"); + end + x = 64'hCD920007FFFFFFFE; + y = 64'hBFF0008000000006; + z = 64'hBFD0008000003FFF; + ans = 64'h4D92009800400005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3820307\n"); + end + x = 64'hE8E000007FFFFEFF; + y = 64'hBFF0000000000000; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'h68E000007FFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3820921\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h475FFFFFFBF7FFFE; + z = 64'hC3D273DDF2EFC5D4; + ans = 64'hC420939EED937E2D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3821535\n"); + end + x = 64'hC1DBFFFFFFFFE000; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3F71FFFFFEFFFFFF; + ans = 64'h41EC0000000003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3822149\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FFB7AD5DBD8ECB4; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3822763\n"); + end + x = 64'hC1DFFFFFFFF00400; + y = 64'h3600000001FDFFFE; + z = 64'h387002000003FFFF; + ans = 64'h386FE400000413FA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3823377\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC000000000000000; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3823991\n"); + end + x = 64'hC33000000000207F; + y = 64'hC06003FFFFFFFFE0; + z = 64'h3FE0000000000000; + ans = 64'h43A0040000002067; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3824605\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC000000000000001; + z = 64'hBFB00000FFF7FFFE; + ans = 64'hBFB00000FFF7FFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3825219\n"); + end + x = 64'hC03CAA2122BCDDA8; + y = 64'h07EFFFF01FFFFFFE; + z = 64'h790FFFFFFFF007FF; + ans = 64'h790FFFFFFFF007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3825833\n"); + end + x = 64'h800DFFFFFF000000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h8000000000000000; + ans = 64'h002BFFFFFDFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3826447\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FB00041FFFFFFFF; + z = 64'hED24C95B210BCE74; + ans = 64'hED24C95B210BCE74; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3827061\n"); + end + x = 64'hBCDFFFFBFFFFFFEF; + y = 64'hC010000000000001; + z = 64'h3FE2B79A1255D879; + ans = 64'h3FE2B79A1255D8B9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3827675\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hBFB611A62F90914B; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3828289\n"); + end + x = 64'h086FFDFFFFF7FFFE; + y = 64'h3F3FFFC00000001F; + z = 64'h3D1FF7FFFF7FFFFF; + ans = 64'h3D1FF7FFFF7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3828903\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFE; z = 64'h4340000000000000; ans = 64'h4340000000000000; rn = 1; @@ -131872,12 +293176,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5649269\n"); + $fwrite(fp,"3829517\n"); end - x = 64'hB0F04000000007FE; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hBFE011E572E754E2; - ans = 64'hBFE011E572E754E2; + x = 64'h09B0000000FFFFEF; + y = 64'hE16F29F8FCB12F99; + z = 64'h3FD0000000000001; + ans = 64'h3FD0000000000001; rn = 1; rz = 0; rm = 0; @@ -131919,12 +293223,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5651283\n"); + $fwrite(fp,"3830131\n"); end - x = 64'hE2DF075DF41FF2E3; - y = 64'h3C140000000001FF; - z = 64'hC361FFFFFBFFFFFF; - ans = 64'hDF03649AB893F9BD; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC340000000000000; + z = 64'hC04000000FEFFFFF; + ans = 64'hC03E00001FDFFFFE; rn = 1; rz = 0; rm = 0; @@ -131966,10 +293270,4522 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5653297\n"); + $fwrite(fp,"3830745\n"); end - x = 64'hFFE0000000000001; + x = 64'hC8001FF7FFFFFFFF; + y = 64'h97DA61766F44B5D2; + z = 64'hC02FFFFFFE010000; + ans = 64'hC02FFFFFFE010000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3831359\n"); + end + x = 64'h40300000000E0000; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3831973\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h4340000000000200; + z = 64'h7FD8E66F7F1B72EF; + ans = 64'h7FD8E66F7F1B72EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3832587\n"); + end + x = 64'hC3D9284299249F71; + y = 64'hFFE0000000000000; + z = 64'h001269432C741CE2; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3833201\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC34000000801FFFE; + z = 64'hC000000000000001; + ans = 64'h3E7003FFF8FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3833815\n"); + end + x = 64'h3FC0000100000FFF; + y = 64'h402F2113B98F4D3F; + z = 64'h41F5067733275A4B; + ans = 64'h41F5067733467B61; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3834429\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h4010000000000001; + ans = 64'h7CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3835043\n"); + end + x = 64'h41FEFFFFF7FFFFFE; + y = 64'h3FDE27B3C3560C4A; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h41ED36761DB16EF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3835657\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hBFC01FFF00000000; + ans = 64'h7CAFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3836271\n"); + end + x = 64'hA140000020FFFFFF; + y = 64'hC02200000001FFFF; + z = 64'hA270000007FFFFDF; + ans = 64'hA26FFFDC0FFFB57A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3836885\n"); + end + x = 64'h3FCFFFFFFF80000F; + y = 64'hFFF0000000000001; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3837499\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC1E0010000000040; + z = 64'h001FFEFFFFFFFFBF; + ans = 64'h3EA001000000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3838113\n"); + end + x = 64'hBE2FDFBFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hC3E0000000000402; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3838727\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h401FFFFF7FFFFDFE; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hC000000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3839341\n"); + end + x = 64'h400AF78C8712BABC; + y = 64'h8020003FFFFFDFFE; + z = 64'h3F0FFFFF02000000; + ans = 64'h3F0FFFFF02000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3839955\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h0000000000000001; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3840569\n"); + end + x = 64'h47FCF758F173AEC0; + y = 64'hB81000003FBFFFFE; + z = 64'h001FFFFFFFFFFFFE; + ans = 64'hC01CF75964DD351E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3841183\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hBFE4000000007FFF; + ans = 64'hBFE4000000007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3841797\n"); + end + x = 64'h407017FFFFFFFFFF; + y = 64'hC34C07FFFFFFFFFF; + z = 64'h3A6F7FFBFFFFFFFF; + ans = 64'hC3CC320BFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3842411\n"); + end + x = 64'h47F000000027FFFF; + y = 64'h0010000000000000; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3843025\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hB7F003FFFFFFEFFE; + z = 64'hC5B7A0673EADC9A4; + ans = 64'hC5B7A0673EADC9A4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3843639\n"); + end + x = 64'h409020000003FFFF; + y = 64'h0010000000000001; + z = 64'hC00FF00000000400; + ans = 64'hC00FF00000000400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3844253\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hC01623760D068163; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFF3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3844867\n"); + end + x = 64'h093FFE0000000001; + y = 64'hBE42C37D10FC5DBF; + z = 64'hBF9EDB6E0C31FE0D; + ans = 64'hBF9EDB6E0C31FE0D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3845481\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; y = 64'h3CA0000000000000; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'h3FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3846095\n"); + end + x = 64'hBFF0800000020000; + y = 64'h002FFFFFFFFFFDE0; + z = 64'h0010000000000000; + ans = 64'h802900000003FDCF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3846709\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h3CA0000000000001; + z = 64'h41EFF8000000003E; + ans = 64'h41EFF8000000003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3847323\n"); + end + x = 64'hC008000001FFFFFF; + y = 64'h4037FFFFDFFFFFFF; + z = 64'h3C5020000007FFFE; + ans = 64'hC051FFFFE97FFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3847937\n"); + end + x = 64'h43D286A2997C9FAA; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000251; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3848551\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h402D452A3DF3776D; + z = 64'hC1EFFFFFFFEFFFBF; + ans = 64'hC1EFFFFFFFEFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3849165\n"); + end + x = 64'h4007FFFFFFFFFF7F; + y = 64'h3FD0000000000000; + z = 64'h7FD5398280BE5715; + ans = 64'h7FD5398280BE5715; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3849779\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h41FF6F065BD57EC9; + z = 64'hBFE0000000000000; + ans = 64'hBFE00003EDE0CB7B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3850393\n"); + end + x = 64'h56CFFFFC00007FFF; + y = 64'hC3FFFDFFFFC00000; + z = 64'hB890000040001FFF; + ans = 64'hDADFFDFC00007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3851007\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3FF0000000000000; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3851621\n"); + end + x = 64'h4031E6B8C563AF80; + y = 64'hBCAFFFFFFF8000FF; + z = 64'h0000000000000001; + ans = 64'hBCF1E6B8C51C152C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3852235\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h3FE0000000000000; + z = 64'hBF463F4F8D229935; + ans = 64'hBF463F4F8D229D35; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3852849\n"); + end + x = 64'hACAFFFFFFFFFFFFB; + y = 64'hC0100000207FFFFF; + z = 64'h3FEFFFFFF01FFFFE; + ans = 64'h3FEFFFFFF01FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3853463\n"); + end + x = 64'h001FFFC000000000; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3854077\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h2929BC17AB77C1CB; + z = 64'h3F203FFFFFFFFFFD; + ans = 64'h3F203FFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3854691\n"); + end + x = 64'hBFFE5222CB6C08EC; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hC02FEFFFFFFFFFDF; + ans = 64'hC031DD222CB6C07E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3855305\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hB807EFFFFFFFFFFF; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3855919\n"); + end + x = 64'hF05000000080007E; + y = 64'hC1F00007FFFFFF7F; + z = 64'h4014EE1CFC92B761; + ans = 64'h725000080080003D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3856533\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h3FE0000000000001; + ans = 64'h3FDFFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3857147\n"); + end + x = 64'hC02DFBFFFFFFFFFE; + y = 64'h47AFF00000080000; + z = 64'hFFFFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3857761\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h3FCF4975D48A2613; + ans = 64'h3FCF4975D48A2603; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3858375\n"); + end + x = 64'hC0FAFEC2EE7775CF; + y = 64'h447FFFFFFFFFFFFF; + z = 64'h3FBF000000FFFFFF; + ans = 64'hC58AFEC2EE7775CE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3858989\n"); + end + x = 64'h45EEE82BC0898FB7; + y = 64'h4000000000000001; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h45FEE82BC0898FB9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3859603\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h402FFFFFFFF00200; + z = 64'hACDFFFDFFFFFFDFE; + ans = 64'hBCEFFFFFFFF001FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3860217\n"); + end + x = 64'h41300001FFFFEFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h41C3B0198D9CC68F; + ans = 64'h41C3D019919CC66F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3860831\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h41A0000200002000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBE60000202001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3861445\n"); + end + x = 64'h401D7976478C5506; + y = 64'h41EFFFFFFF800200; + z = 64'h37FFF07FFFFFFFFF; + ans = 64'h421D797647167104; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3862059\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h4010000000000001; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3862673\n"); + end + x = 64'h37E200FFFFFFFFFF; + y = 64'hBFF00000008001FF; + z = 64'hFFEFFFFFFFFFFFFE; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3863287\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3FBF000007FFFFFF; + ans = 64'h3FBF000007FFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3863901\n"); + end + x = 64'h706FFFFFFFEFEFFF; + y = 64'hBB2007994AC8C940; + z = 64'h43EFFFFFF0000001; + ans = 64'hEBA007994AC0BD6F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3864515\n"); + end + x = 64'hBFDFFEFFFDFFFFFE; + y = 64'h4340000000000000; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'hC32FFEFFFDFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3865129\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h7D2A71E23A26FE39; + z = 64'hC3CEDFFFFFFFFFFF; + ans = 64'hF9EA71E23A26FE37; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3865743\n"); + end + x = 64'hB7E7FFEFFFFFFFFF; + y = 64'h4340000000000001; + z = 64'h3FF0262BF9110EA2; + ans = 64'h3FF0262BF9110EA2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3866357\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hFFF28BE96C71A6EB; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hFFFA8BE96C71A6EB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3866971\n"); + end + x = 64'hC34BFFBFFFFFFFFE; + y = 64'h4020003FFFFFFFFC; + z = 64'hC000000000000203; + ans = 64'hC37C002FFEFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3867585\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h7FE0000000000000; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'hFC9FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3868199\n"); + end + x = 64'h4070000000000047; + y = 64'h3FD001FFFFFFFFF6; + z = 64'hFFE0000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3868813\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'h41C000F800000000; + ans = 64'hFCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3869427\n"); + end + x = 64'h480000000800007F; + y = 64'hC1DFFFFFFFFFFFFE; + z = 64'h480D431676A71F4C; + ans = 64'hC9F0000007C57A51; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3870041\n"); + end + x = 64'hC1E0C51250FC8976; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h3FF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3870655\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h41EE000000000007; + z = 64'hC1E010000007FFFE; + ans = 64'hC1E0100000080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3871269\n"); + end + x = 64'h41AFF68C1CC9C0A1; + y = 64'h7FF0000000000000; + z = 64'h434FFFFFFFBFFEFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3871883\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h3FFFFFFFBFFFBFFF; + z = 64'h8010000000000000; + ans = 64'hBCBFFFFFBFFFBFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3872497\n"); + end + x = 64'h400DC9E58AFDDB5A; + y = 64'h47EFFFFDFFFFFFFA; + z = 64'h001FFFFFFFFFC200; + ans = 64'h480DC9E3AE5F82A5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3873111\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3CA0000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3873725\n"); + end + x = 64'hBFF0007FFFBFFFFF; + y = 64'hBFDCC57F4F7CBEBC; + z = 64'hC340000000000001; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3874339\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h8000000000000000; + z = 64'h5E2FFFFFFFFFFFE8; + ans = 64'h5E2FFFFFFFFFFFE8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3874953\n"); + end + x = 64'hBE91FFFFFFFFFFFA; + y = 64'h40A000000FFFBFFF; + z = 64'hC0207FEFFFFFFFFE; + ans = 64'hC0208038000047FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3875567\n"); + end + x = 64'h3FFFC001FFFFFFFE; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h3FE0000000000001; + ans = 64'h3FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3876181\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hC1A000000000006E; + z = 64'h37E0000100010000; + ans = 64'h3E6000000000006D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3876795\n"); + end + x = 64'h3FEFF7EFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hFFD3413A55613D63; + ans = 64'hFFD3413A55613D63; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3877409\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h001FFFFFFFFC0000; + z = 64'h8000000000000001; + ans = 64'h8000000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3878023\n"); + end + x = 64'hCE58341C1FDF7D8E; + y = 64'hC02FFFFFFFFE0007; + z = 64'hC340010000100000; + ans = 64'h4E98341C1FDDFA52; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3878637\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h0010000000000001; + ans = 64'h0010000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3879251\n"); + end + x = 64'hCDFFFFFFFFFF803F; + y = 64'h52CFBFFFE0000000; + z = 64'hC01FFFFFFFFFFFFF; + ans = 64'hE0DFBFFFDFFF813F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3879865\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBC7000007FFFFFBF; + ans = 64'hBC7000007FFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3880479\n"); + end + x = 64'h7FFFFFDFFFFFF7FF; + y = 64'hBFFEAF36380E1453; + z = 64'h43401FFFFFFEFFFF; + ans = 64'h7FFFFFDFFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3881093\n"); + end + x = 64'hC7E000000000041F; + y = 64'hBCA0000000000001; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h4490000000000420; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3881707\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h4340011FFFFFFFFF; + z = 64'hC48F000001FFFFFF; + ans = 64'hC48F000001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3882321\n"); + end + x = 64'hFFFBFFFFFFFFFEFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3F400000011FFFFE; + ans = 64'hFFFBFFFFFFFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3882935\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h40207F0000000000; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3883549\n"); + end + x = 64'h971F800000001FFE; + y = 64'hD6EC0000FFFFFFFF; + z = 64'h38DFFFFFFC000001; + ans = 64'h38DFFFFFFC000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3884163\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hBFD0000000000001; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h3C90000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3884777\n"); + end + x = 64'h7943721AAF4997DF; + y = 64'h4F40100000001FFE; + z = 64'hC00FFFFFFFFFFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3885391\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC03DFFFFEFFFFFFE; + ans = 64'hC03DFFFFEFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3886005\n"); + end + x = 64'hC02FFFFFFFFD0000; + y = 64'h409FFFFFE0003FFF; + z = 64'h41F000800000000E; + ans = 64'h41F000780000080F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3886619\n"); + end + x = 64'hBCA8CBF09B3D0FC8; + y = 64'hBFE0000000000000; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h3CB632FC26CF43F1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3887233\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hBFE0000004000040; + z = 64'h3FCA4E5DFC5F64A6; + ans = 64'h3FCA4E5DFC5F64AA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3887847\n"); + end + x = 64'hC7FFF000000FFFFF; + y = 64'hBFE0000000000001; + z = 64'h3B988E26CAA0A643; + ans = 64'h47EFF00000100001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3888461\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hBFFA89B78C407B0B; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3889075\n"); + end + x = 64'h7FEC5FED92358A74; + y = 64'h400000001BFFFFFF; + z = 64'hFFEFC0003FFFFFFE; + ans = 64'h7FE8FFDB47BAD466; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3889689\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFE; z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; @@ -132013,12 +297829,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5655311\n"); + $fwrite(fp,"3890303\n"); end - x = 64'h3FDFE00000040000; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h4C80000008800000; - ans = 64'h4C80000008800000; + x = 64'h3E5003FFFFFFFFFE; + y = 64'h42A0000100000008; + z = 64'hC000000000000000; + ans = 64'h410003F100400006; rn = 1; rz = 0; rm = 0; @@ -132060,12 +297876,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5657325\n"); + $fwrite(fp,"3890917\n"); end - x = 64'hBFDFFFFFF0003FFF; - y = 64'hB7EFFFFFFE00000F; - z = 64'hC000000000FFFFF0; - ans = 64'hC000000000FFFFF0; + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hBFF0000000000001; + z = 64'h3F90FFFE00000000; + ans = 64'h3F90FFFE00000040; rn = 1; rz = 0; rm = 0; @@ -132107,12 +297923,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5659339\n"); + $fwrite(fp,"3891531\n"); end - x = 64'hFFE0000000000001; - y = 64'h3FE0000000000000; - z = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hFFD0000000000001; + x = 64'h43A379C662D1E18D; + y = 64'hBFEFFFFFFFFFFE0E; + z = 64'hCE7FFD7FFFFFFFFF; + ans = 64'hCE7FFD7FFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -132154,12 +297970,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5661353\n"); + $fwrite(fp,"3892145\n"); end - x = 64'hC0CE6B6DEFF071A3; - y = 64'h3FEFFFFFFFFFFFFE; - z = 64'h3F9FF00000FFFFFE; - ans = 64'hC0CE6B69F1F07181; + x = 64'h3F700000000BFFFE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h3CA0000000000000; + ans = 64'hBF800000000BFFBD; rn = 1; rz = 0; rm = 0; @@ -132201,12 +298017,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5663367\n"); + $fwrite(fp,"3892759\n"); end - x = 64'hEB6FFFFFF7FFFF7F; - y = 64'h40B000800000001F; - z = 64'hC1CFFFFFC0000010; - ans = 64'hEC30007FFBFFDFDE; + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hB81AEAA04CF56914; + z = 64'h43EFE00000010000; + ans = 64'h43EFE00000010000; rn = 1; rz = 0; rm = 0; @@ -132248,12 +298064,2174 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5665381\n"); + $fwrite(fp,"3893373\n"); end - x = 64'hFFE0000000000001; - y = 64'h4000000000000000; + x = 64'hBFFEFFFFFEFFFFFE; + y = 64'hC000000000000000; + z = 64'h9CF00401FFFFFFFE; + ans = 64'h400EFFFFFEFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3893987\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hBF1FC0000001FFFF; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3894601\n"); + end + x = 64'h48000200000007FF; + y = 64'hC7E804BB70801D06; + z = 64'h402BCF7F1D62AAF3; + ans = 64'hCFF807BC07EE390A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3895215\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3895829\n"); + end + x = 64'hC01816EFAAB2D8D7; + y = 64'hC3DFFFBFFFFF7FFF; + z = 64'hBFF0000000000001; + ans = 64'h440816BF7CD32315; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3896443\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hC010000000000000; + z = 64'h37F8101B8771DC21; + ans = 64'h3CCFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3897057\n"); + end + x = 64'hC347ED246FACE56C; + y = 64'h41B00000FFFFFBFF; + z = 64'hC3C01FFFFFFFE000; + ans = 64'hC507ED26F07F266A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3897671\n"); + end + x = 64'h43D34792C6A02B3D; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h0010000000000001; + ans = 64'hC4034792C6A02B3C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3898285\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h801974EC8F423A9C; + z = 64'h7FEFFFFFFFFFF5FE; + ans = 64'h7FEFFFFFFFFFF5FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3898899\n"); + end + x = 64'hBFD000001FFFFF7F; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hC6C6597A88729CE8; + ans = 64'hC6C6597A88729CE8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3899513\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hC1DFFFFFFFFDDFFF; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3900127\n"); + end + x = 64'h3E90001FFFFBFFFF; + y = 64'h000007FFFFFFFEFF; + z = 64'h43FFEFFFFFFFFFEF; + ans = 64'h43FFEFFFFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3900741\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hC340000000000001; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3901355\n"); + end + x = 64'h354C0618970ED58A; + y = 64'hC29FFFFDFFFFFFFB; + z = 64'hBFEFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3901969\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hBFEFC000FFFFFFFF; + ans = 64'h40080FFFBFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3902583\n"); + end + x = 64'hC008000007FFFFFF; + y = 64'hC3E0007FDFFFFFFE; + z = 64'hC020001FFFF7FFFE; + ans = 64'h43F800BFD8003FEC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3903197\n"); + end + x = 64'h7FE037FFFFFFFFFF; + y = 64'hFFE0000000000001; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3903811\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h43EFFFFFFFFFC1FF; + z = 64'hC08FFFFFFFFFE080; + ans = 64'hC0B3FFFFFFFFDD0F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3904425\n"); + end + x = 64'hC1C000000001007E; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h37F0000000000808; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3905039\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h47EE1258EDCF0B99; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'hC4AE1258EDCF0B97; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3905653\n"); + end + x = 64'hC01FF00100000000; + y = 64'h37E2C1CE2980BFCB; + z = 64'hBFF000C000000000; + ans = 64'hBFF000C000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3906267\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hFFF0000000000000; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3906881\n"); + end + x = 64'h415FED03662395C2; + y = 64'h3CF003FFFFC00000; + z = 64'hBFDFFFFFFFFFFFFE; + ans = 64'hBFDFFFFFE00B0158; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3907495\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hB81FFFFFFFFFF7C0; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3908109\n"); + end + x = 64'h7FEFFFDFFFFFF000; + y = 64'h3E92B79EE102830F; + z = 64'h404FF80002000000; + ans = 64'h7E92B78C296398B1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3908723\n"); + end + x = 64'h3FCFFFFFFFFFEEFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3909337\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC463FFFFFFFF7FFF; + z = 64'hB80FFFFFFF0001FE; + ans = 64'h4443FFFFFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3909951\n"); + end + x = 64'h41DFFF7FFFFFFFFD; + y = 64'h0000000000000001; + z = 64'h40074A735CCC3D1A; + ans = 64'h40074A735CCC3D1A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3910565\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBE700000003DFFFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h4010000000FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3911179\n"); + end + x = 64'hC0EFFFFFFFFFFBFE; + y = 64'hBFB5337C5E8A0ADB; + z = 64'h403FFFFFFFF80100; + ans = 64'h40B5537C5E8A0034; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3911793\n"); + end + x = 64'hBFD0000000000000; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3912407\n"); + end + x = 64'h40FBFFEFFFFFFFFF; + y = 64'h407BCCA8CD7A0FA4; + z = 64'hBFD0000000000000; + ans = 64'h41885305CB7666F2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3913021\n"); + end + x = 64'hBFD0000000000000; + y = 64'h0010000000000001; + z = 64'h47FBFF8000000000; + ans = 64'h47FBFF8000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3913635\n"); + end + x = 64'h80070F86D26AF87F; + y = 64'h402D24956BD2F299; + z = 64'h3FEFFFFFFEFFFFDF; + ans = 64'h3FEFFFFFFEFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3914249\n"); + end + x = 64'h802FB75B257B0ED8; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3914863\n"); + end + x = 64'hBFD0000000000000; + y = 64'h3E10000000000000; + z = 64'hB7E8C5327331971D; + ans = 64'hBDF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3915477\n"); + end + x = 64'h3FF0020000010000; + y = 64'h3CA0000000000000; + z = 64'hBFDBFFFFFFFFFFC0; + ans = 64'hBFDBFFFFFFFFFFBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3916091\n"); + end + x = 64'hBFD0000000000000; + y = 64'h3ABFFFFFF7FFBFFF; + z = 64'h4000000000000000; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3916705\n"); + end + x = 64'h3FCB02720DAF3235; + y = 64'h43E4A66C2CF152B0; + z = 64'h41DFC544AD43CD91; + ans = 64'h43C16DFF46A401F7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3917319\n"); + end + x = 64'hBFD0000000000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3917933\n"); + end + x = 64'hB7E00000003BFFFF; + y = 64'h3FDFFFFFFFF7DFFF; + z = 64'hBCA0000000000001; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3918547\n"); + end + x = 64'hBFD0000000000000; + y = 64'h3FD0000000000000; + z = 64'h48000000000FFE00; + ans = 64'h48000000000FFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3919161\n"); + end + x = 64'hC03B47150C9A9B6D; + y = 64'hB2100800000001FF; + z = 64'h41200001FFFFFBFE; + ans = 64'h41200001FFFFFBFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3919775\n"); + end + x = 64'hC800003FFFEFFFFF; + y = 64'h3FD0000000000001; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3920389\n"); + end + x = 64'hBFD0000000000000; + y = 64'h43CFFFFFFFFEDFFE; + z = 64'h7FD69279CD05B983; + ans = 64'h7FD69279CD05B983; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3921003\n"); + end + x = 64'hBFDE7D87C0913C02; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3FDFFF7FFFFFBFFE; + ans = 64'h3FD0C0BC1FB721FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3921617\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBFCFFF8000008000; z = 64'h3FF0000000000001; - ans = 64'hFFF0000000000000; + ans = 64'h3FF0FFFC00000401; rn = 1; rz = 0; rm = 0; @@ -132295,12 +300273,576 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5667395\n"); + $fwrite(fp,"3922231\n"); end - x = 64'h43DFFFFFFFFF7BFF; + x = 64'hE561400000000000; + y = 64'h3370010000000080; + z = 64'h3FEFFC0000000FFF; + ans = 64'hD8E141140000008A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3922845\n"); + end + x = 64'hBFD0000000000000; + y = 64'h3FE0000000000001; + z = 64'hC000000000000001; + ans = 64'hC001000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3923459\n"); + end + x = 64'hB61FDFFFFFFFFF80; + y = 64'hC07FF7FFF7FFFFFF; + z = 64'h801FFFFFFFFFFFFF; + ans = 64'h36AFD807F807FF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3924073\n"); + end + x = 64'hBFD0000000000000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h6F9000201FFFFFFF; + ans = 64'h6F9000201FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3924687\n"); + end + x = 64'hF8A00000400007FF; + y = 64'hC3CFFFFFFFFFE000; + z = 64'hBCD00FFFFFFFFFF6; + ans = 64'h7C8000003FFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3925301\n"); + end + x = 64'hC020000007FFFFBF; + y = 64'h3FF0000000000000; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC350000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3925915\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC9F4F59F1F927A15; + z = 64'h45E2000000000007; + ans = 64'h49D4F59F1F927A15; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3926529\n"); + end + x = 64'h7FFE000000000003; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h8027230E8C392E66; + ans = 64'h7FFE000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3927143\n"); + end + x = 64'hBFD0000000000000; + y = 64'h402881AE9E66C7A0; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'hC00081AE9E66C7A0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3927757\n"); + end + x = 64'h3FF07FF000000000; + y = 64'hB7E591AE07EF0EC1; + z = 64'hBFA20001FFFFFFFE; + ans = 64'hBFA20001FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3928371\n"); + end + x = 64'hBFD0000000000000; + y = 64'h4000000000000000; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hC004000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3928985\n"); + end + x = 64'h41F0000000FFF7FE; + y = 64'hB43FFFFFE0000000; + z = 64'h800FFFFFFFFFFFFE; + ans = 64'hB63FFFFFE1FFEFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3929599\n"); + end + x = 64'hBFD0000000000000; y = 64'h400FFFFFFFFFFFFF; - z = 64'hC9E8F802949944EB; - ans = 64'hC9E8F802949944EB; + z = 64'h401FFFF7FFFFBFFF; + ans = 64'h401BFFF7FFFFBFFF; rn = 1; rz = 0; rm = 0; @@ -132342,12 +300884,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5669409\n"); + $fwrite(fp,"3930213\n"); end - x = 64'hBFCFF8000003FFFF; - y = 64'hC0C00000007FBFFF; - z = 64'hBFF0000001000007; - ans = 64'h409FF4000103001D; + x = 64'h41E0020007FFFFFE; + y = 64'hBFCFFFFFFFF80000; + z = 64'h41CC685C7196EB8B; + ans = 64'h41B8CCB8D335D81A; rn = 1; rz = 0; rm = 0; @@ -132389,11 +300931,528 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5671423\n"); + $fwrite(fp,"3930827\n"); end - x = 64'hFFE0000000000001; + x = 64'hD59FFFFFFFFFFF02; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hD5BFFFFFFFFFFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3931441\n"); + end + x = 64'hBFD0000000000000; + y = 64'h3ECF0000001FFFFE; + z = 64'hC07FFFFFF7FFFF00; + ans = 64'hC07FFFFFF8F7FF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3932055\n"); + end + x = 64'hD3207FFFF8000000; + y = 64'h4010000000000001; + z = 64'h802FFF7FF7FFFFFF; + ans = 64'hD3407FFFF8000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3932669\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC1E000000000EFFF; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h41C000000040EFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3933283\n"); + end + x = 64'h47E0001FFEFFFFFF; + y = 64'h3E00080001FFFFFF; + z = 64'h3F80400001FFFFFE; + ans = 64'h45F0082010FF83FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3933897\n"); + end + x = 64'hBFD0000000000000; y = 64'h401FFFFFFFFFFFFE; - z = 64'hC340000000000000; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hC007FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3934511\n"); + end + x = 64'h43CFFFFFFFFFBFFC; + y = 64'h48000103FFFFFFFF; + z = 64'h8000000000000000; + ans = 64'h4BE00103FFFFDFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3935125\n"); + end + x = 64'hBFD0000000000000; + y = 64'h4340000000000001; + z = 64'hB2A1894A6694767C; + ans = 64'hC320000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3935739\n"); + end + x = 64'hBFF00000001FFFDF; + y = 64'h43E49E7F564BB504; + z = 64'h3FDFF80000800000; + ans = 64'hC3E49E7F5674F1D8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3936353\n"); + end + x = 64'h326FFF0000001FFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hC010000000000000; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3936967\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBFB0000080800000; + z = 64'h5CBFFFFFFFC00010; + ans = 64'h5CBFFFFFFFC00010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3937581\n"); + end + x = 64'hC04C000000000002; + y = 64'h7FE0000000000000; + z = 64'hC7F0003FFF800000; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -132436,12 +301495,5182 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5673437\n"); + $fwrite(fp,"3938195\n"); end - x = 64'h41E9904CF9E46D4D; + x = 64'hBFD0000000000000; + y = 64'hB7F00000000FEFFE; + z = 64'h3FD0000000000000; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3938809\n"); + end + x = 64'hC07FFFFF000000FF; + y = 64'h401FFFFFFC000800; + z = 64'hBFFE3FFFFFFFFFFF; + ans = 64'hC0B001E37E00048F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3939423\n"); + end + x = 64'hBFD0000000000000; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hBFE0000000000000; + ans = 64'hFFCFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3940037\n"); + end + x = 64'h43D45470894BB8A8; + y = 64'hC03FBFFFBFFFFFFF; + z = 64'h7FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3940651\n"); + end + x = 64'hBFD0000000000000; + y = 64'h7FF0000000000000; + z = 64'hC0100000000077FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3941265\n"); + end + x = 64'hC1CF9BD668BBFDD4; + y = 64'h47FFFFFFFC00000F; + z = 64'h3FF0000203FFFFFE; + ans = 64'hC9DF9BD664C88316; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3941879\n"); + end + x = 64'h94B6F716776052E0; + y = 64'h7FF0000000000001; + z = 64'hC000000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3942493\n"); + end + x = 64'hBFD0000000000000; + y = 64'h7FF0001000001FFE; + z = 64'h3FCD83E74EDEE6A0; + ans = 64'h7FF8001000001FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3943107\n"); + end + x = 64'h3F8FFFFFDFFFBFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3ECFE0003FFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3943721\n"); + end + x = 64'hBFD0000000000000; + y = 64'h43C6363479265EB6; + z = 64'h3CA0000000000001; + ans = 64'hC3A6363479265EB6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3944335\n"); + end + x = 64'hBE7FFFFFE0007FFF; + y = 64'h3F8FFFFFFFFFF820; + z = 64'h48000000003FFE00; + ans = 64'h48000000003FFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3944949\n"); + end + x = 64'hBFD0000000000000; + y = 64'h8000000000000001; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3945563\n"); + end + x = 64'h7FFE5CD16B7C0732; + y = 64'h3CADFFFFFFDFFFFF; + z = 64'h7FEFFFFFFFFFFFFF; + ans = 64'h7FFE5CD16B7C0732; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3946177\n"); + end + x = 64'hBFD0000000000000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h409BFFFFEFFFFFFF; + ans = 64'h409BFFFFEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3946791\n"); + end + x = 64'hBF9FFFFFEFFFFFC0; + y = 64'h381EF14093430C09; + z = 64'hD060000FFFFFC000; + ans = 64'hD060000FFFFFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3947405\n"); + end + x = 64'h00200001FFFFF000; + y = 64'h8010000000000000; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3948019\n"); + end + x = 64'hBFD0000000000000; + y = 64'h8023FFFFFFFFFFF6; + z = 64'hC3EFFFFFFFFF007F; + ans = 64'hC3EFFFFFFFFF007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3948633\n"); + end + x = 64'hA60FDFFFBFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hC7FBFFC000000000; + ans = 64'hC7FBFFC000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3949247\n"); + end + x = 64'hBFD0000000000000; + y = 64'h498168AE9F10A60B; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'hC96168AE9F10A60B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3949861\n"); + end + x = 64'h400FFFEFFBFFFFFF; + y = 64'h3FC000FF7FFFFFFF; + z = 64'h4F83DECC52B7FEC8; + ans = 64'h4F83DECC52B7FEC8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3950475\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBCA0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCABFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3951089\n"); + end + x = 64'h000FFF7FFBFFFFFE; + y = 64'h37EFFE003FFFFFFE; + z = 64'h434FFFFFFFFFFFFE; + ans = 64'h434FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3951703\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h7FF00000000007FF; + ans = 64'h7FF80000000007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3952317\n"); + end + x = 64'h3FB00000000BFFFF; + y = 64'hC1F4D10E1B0B1A8D; + z = 64'h323FFFFFC000003E; + ans = 64'hC1B4D10E1B1AB756; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3952931\n"); + end + x = 64'hFE40041FFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'h7B00041FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3953545\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC1CFFFFF00000080; + z = 64'h592B8A3E51BB758C; + ans = 64'h592B8A3E51BB758C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3954159\n"); + end + x = 64'hB7E28718D241C8CE; + y = 64'hBFD0000000000001; + z = 64'hC5BFFFE00000000F; + ans = 64'hC5BFFFE00000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3954773\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC1C0ECDAF428D873; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h41A0ECDAF428D873; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3955387\n"); + end + x = 64'hC1D01FFFFEFFFFFF; + y = 64'hBD900000000017FE; + z = 64'h4020000100000006; + ans = 64'h40200204FFFFE009; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3956001\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h3FBFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3956615\n"); + end + x = 64'hBFECB2362DE0F377; + y = 64'hC7FFFFFFF00003FE; + z = 64'h4340000000000000; + ans = 64'h47FCB2361F87DBF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3957229\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBFE0000000000001; + z = 64'hC0EB2BD633D0A462; + ans = 64'hC0EB2BD233D0A462; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3957843\n"); + end + x = 64'hC4909D047E2E3993; + y = 64'h3FC0021FFFFFFFFE; + z = 64'hC1D029717C79EE32; + ans = 64'hC4609F3958C703C9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3958457\n"); + end + x = 64'h3FD3FFFFFFFFFDFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBFE0000000000000; + ans = 64'hBFE9FFFFFFFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3959071\n"); + end + x = 64'hBFD0000000000000; + y = 64'h8011FFFFFFFBFFFF; + z = 64'hC0B0000000402000; + ans = 64'hC0B0000000402000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3959685\n"); + end + x = 64'hBFD0000007FFFBFF; + y = 64'hBFF0000000000000; + z = 64'h3F30000040020000; + ans = 64'h3FD00400080FFC7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3960299\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC1F01FFFFFFFFFDF; + z = 64'h0000000000000000; + ans = 64'h41D01FFFFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3960913\n"); + end + x = 64'h4062E6BD1223E0B2; + y = 64'h37F0021FFFFFFFFF; + z = 64'h002C0007FFFFFFFF; + ans = 64'h3862E93FB7404975; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3961527\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h8010000000000000; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3962141\n"); + end + x = 64'h80072CA6F5A92C4D; + y = 64'hB7EE00001FFFFFFF; + z = 64'h4010000000000001; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3962755\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC000000000000000; + z = 64'h3FF0007FFFFFFFFB; + ans = 64'h3FF8007FFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3963369\n"); + end + x = 64'hC0139A6B29FE9D78; + y = 64'h4DEFFAFFFFFFFFFF; + z = 64'h421DFE0000000000; + ans = 64'hCE13975B09400DAF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3963983\n"); + end + x = 64'hBB4FFFFFFE000007; + y = 64'hC000000000000001; + z = 64'hBFD0000000000001; + ans = 64'hBFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3964597\n"); + end + x = 64'hBFD0000000000000; + y = 64'h3E1000020003FFFF; + z = 64'h407EFFFFFFBFFFFF; + ans = 64'h407EFFFFFFBFEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3965211\n"); + end + x = 64'hC8000007FFFFFEFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hC03FFFFFFFDFFFE0; + ans = 64'h48200007FFFFFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3965825\n"); + end + x = 64'hBFD0000000000000; + y = 64'h37E0000010000000; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3966439\n"); + end + x = 64'hBFEFFFFFFDFFFFDE; + y = 64'hFFEBFFFFFFFE0000; + z = 64'h3FB0800000000020; + ans = 64'h7FEBFFFFFE3DFFE2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3967053\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC010000000000001; + z = 64'h8000000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3967667\n"); + end + x = 64'h29D0003F7FFFFFFF; + y = 64'hC3D05FFFFFFFFFFF; + z = 64'h400FFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3968281\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h41F9A49D2E0B0DFF; + ans = 64'h41F9A49D2E2B0DFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3968895\n"); + end + x = 64'hC280000FFEFFFFFF; + y = 64'h3FD0000FFFEFFFFE; + z = 64'h43DC00000000FFFF; + ans = 64'h43DBFFFFE000C001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3969509\n"); + end + x = 64'hC80679B587B79104; + y = 64'hC340000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h4B5679B587B79104; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3970123\n"); + end + x = 64'hBFD0000000000000; + y = 64'h5CC53197EE2C973A; + z = 64'h1AD0FF0000000000; + ans = 64'hDCA53197EE2C973A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3970737\n"); + end + x = 64'hC14F1FFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC3EF6FA933DE8BF0; + ans = 64'h44AF1E09056CC215; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3971351\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBFB00000FDFFFFFF; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3971965\n"); + end + x = 64'hC80FFFFF7F7FFFFF; + y = 64'h279FFFFFBFFFFF80; + z = 64'hC06100000000003E; + ans = 64'hC06100000000003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3972579\n"); + end + x = 64'hBFD0000000000000; + y = 64'hFFE0000000000000; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3973193\n"); + end + x = 64'hBF60003FFFFFFFBF; + y = 64'h4320003EF7E4B7E8; + z = 64'h3FFFFFFFFFFFFFFE; + ans = 64'hC290007EF8E08F3A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3973807\n"); + end + x = 64'hBFD0000000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h47F384676A9D2C88; + ans = 64'h7FCFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3974421\n"); + end + x = 64'h3D0FFFFFFFFC00FF; + y = 64'hB61FFFFFF0000007; + z = 64'hC078FFFFFFFFFFFF; + ans = 64'hC078FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3975035\n"); + end + x = 64'h3C0FFFFFFFFBBFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'hFC0FFFFFFFFBBFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3975649\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC0FB7ABF90C30569; + z = 64'hAA8003FFFFFFFFFA; + ans = 64'h40DB7ABF90C30569; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3976263\n"); + end + x = 64'h4974638EBBF64A3F; + y = 64'hFFF0000000000001; + z = 64'h00200080000FFFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3976877\n"); + end + x = 64'hBFD0000000000000; + y = 64'h07E47CFB53657A81; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3977491\n"); + end + x = 64'hC1BFFFEFFFEFFFFE; + y = 64'hBFEFFFFFFDFFF000; + z = 64'hBFBBFFFFFFFFF800; + ans = 64'h41BFFFEFFDD3F0FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3978105\n"); + end + x = 64'hBFD0000000000000; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3978719\n"); + end + x = 64'hC05FFFFFFFFF803F; + y = 64'hEA7FFF007FFFFFFF; + z = 64'h3FF0000000000000; + ans = 64'h6AEFFF007FFF8042; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3979333\n"); + end + x = 64'hBFD0000000000001; + y = 64'h0000000000000001; + z = 64'h41B8C52945BBFAB5; + ans = 64'h41B8C52945BBFAB5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3979947\n"); + end + x = 64'h090000000000000F; + y = 64'h8013DEB27E87ED71; + z = 64'h354FFEFFFFFFF000; + ans = 64'h354FFEFFFFFFF000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3980561\n"); + end + x = 64'h400FFFE000000010; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h8010000000000000; + ans = 64'h0027FFE00000000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3981175\n"); + end + x = 64'hBFD0000000000001; + y = 64'h39BFFFFE00000007; + z = 64'h40345ABEA176FD65; + ans = 64'h40345ABEA176FD65; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3981789\n"); + end + x = 64'hC02313215AE5236A; + y = 64'h0010000000000000; + z = 64'h380FFFFFFFC00000; + ans = 64'h380FFFFFFFC00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3982403\n"); + end + x = 64'hBFD0000000000001; + y = 64'h3FFEFFFFFFFFC000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3983017\n"); + end + x = 64'hC3E00000003FBFFF; + y = 64'h3F900000002FFFFF; + z = 64'hBABB1E081B1414D0; + ans = 64'hC3800000006FBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3983631\n"); + end + x = 64'hBFD0000000000001; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3984245\n"); + end + x = 64'h7B4FFE0001FFFFFF; + y = 64'hB94FFFFFFFE0000F; + z = 64'h3FE0000000000001; + ans = 64'hF4AFFE0001E0020E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3984859\n"); + end + x = 64'hBFD0000000000001; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hC80FFFDE00000000; + ans = 64'hC80FFFDE00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3985473\n"); + end + x = 64'h43EFE0000007FFFF; + y = 64'h801B33C01CF5799F; + z = 64'h4036381A5D52DCFF; + ans = 64'h4036381A5D52DCFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3986087\n"); + end + x = 64'h3E3FFFEF00000000; + y = 64'h3CA0000000000001; + z = 64'h8000000000000001; + ans = 64'h3AEFFFEF00000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3986701\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC2963A2744C815E7; + z = 64'h5770FFF800000000; + ans = 64'h5770FFF800000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3987315\n"); + end + x = 64'h002FFFFFEFFFFFF7; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h43C15567C6CBF43C; + ans = 64'h43C15567C6CBF43C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3987929\n"); + end + x = 64'hBFD0000000000001; + y = 64'h43F0040000000001; + z = 64'hC010000000000001; + ans = 64'hC3D0040000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3988543\n"); + end + x = 64'h41E67E7D7E29C6E8; + y = 64'h80113BE435615CD1; + z = 64'hC7EFFBFFFFFFBFFE; + ans = 64'hC7EFFBFFFFFFBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3989157\n"); + end + x = 64'hBFD0000000000001; + y = 64'h3FD0000000000001; + z = 64'h4340000000000001; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3989771\n"); + end + x = 64'hC1C0008000001FFF; + y = 64'hC1E8B82EC582271A; + z = 64'h3FDFFFFFFFFFFFFF; + ans = 64'h43B8B8F486F8849A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3990385\n"); + end + x = 64'hBFD0000000000001; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hC0001FFFFFEFFFFF; + ans = 64'hC0011FFFFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3990999\n"); + end + x = 64'h3ED37FFFFFFFFFFE; + y = 64'hFFF5DF829A8187D2; + z = 64'h3FC00000001FFFFF; + ans = 64'hFFFDDF829A8187D2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3991613\n"); + end + x = 64'hBFA000007FFF7FFF; + y = 64'h3FE0000000000000; + z = 64'h7FFFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3992227\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC3E30BB4858318FD; + z = 64'h43D00000000010FE; + ans = 64'h43D985DA42C19D7D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3992841\n"); + end + x = 64'hCDAFFE00000001FE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3F1FFFFFFFC01FFF; + ans = 64'hCDAFFE00000001FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3993455\n"); + end + x = 64'hBFD0000000000001; + y = 64'h43FFFFFDFF000000; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'hC3DFFFFDFF000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3994069\n"); + end + x = 64'hB800000007FFFFFF; + y = 64'h7FDF5D2DD7E7752E; + z = 64'h40AF553D70AC8668; + ans = 64'hF7EF5D2DE7960C18; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3994683\n"); + end + x = 64'hBFD0000000000001; + y = 64'h3FF0000000000000; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401EFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3995297\n"); + end + x = 64'hC80000000FDFFFFF; + y = 64'hC3DFFFFFFFFFFC0F; + z = 64'h3CAFFFFFFFFFFFFE; + ans = 64'h4BF000000FDFFE06; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3995911\n"); + end + x = 64'hBFD0000000000001; + y = 64'h3FF0000000000001; + z = 64'hBE8200001FFFFFFF; + ans = 64'hBFD0000090000102; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3996525\n"); + end + x = 64'h37EB27DD446055AC; + y = 64'h3CA0200000008000; + z = 64'h00120000001FFFFE; + ans = 64'h349B5E2CFEE9EF96; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3997139\n"); + end + x = 64'h41ED268E2DEAC13F; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFFFFFE; + ans = 64'h7FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3997753\n"); + end + x = 64'hBFD0000000000001; + y = 64'hBFE139D0B510463B; + z = 64'h417F800000000008; + ans = 64'h417F800002273A1F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3998367\n"); + end + x = 64'h47FFFFFFEFF7FFFE; + y = 64'h4000000000000000; + z = 64'h877000007FFFFFFF; + ans = 64'h480FFFFFEFF7FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3998981\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC03007FFFDFFFFFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'h40000FFFFC000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3999595\n"); + end + x = 64'h40000000000000FF; + y = 64'h403FFFFFFFFFF00F; + z = 64'h3FDFFFFF7FFFFF7F; + ans = 64'h40501FFFFF7FF906; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4000209\n"); + end + x = 64'hBFD0000000000001; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h4007FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4000823\n"); + end + x = 64'hC030400010000000; + y = 64'h43E80000000003FF; + z = 64'h3CA0000000000000; + ans = 64'hC42860001800040F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4001437\n"); + end + x = 64'hBFD0000000000001; + y = 64'h4010000000000000; + z = 64'h401FFFFFDFFFDFFF; + ans = 64'h401BFFFFDFFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4002051\n"); + end + x = 64'hC80FFFFF40000000; + y = 64'hC2FFFDDFFFFFFFFE; + z = 64'hBFBFFE0FFFFFFFFF; + ans = 64'h4B1FFDDF400CBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4002665\n"); + end + x = 64'h41EFFFFFFFDFFFDF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h7FE0000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4003279\n"); + end + x = 64'hBFD0000000000001; + y = 64'h403FFFFFFFC00FFF; + z = 64'h3FBBFFFFFBFFFFFE; + ans = 64'hC01F8FFFFFD01001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4003893\n"); + end + x = 64'h7FE0000000FFFFFE; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hBFC00007FFFFFFFB; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4004507\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC1E168099A1FC31E; + z = 64'hBFF0000000000000; + ans = 64'h41C16809999FC31F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4005121\n"); + end + x = 64'hC0CBD59D6AA012B6; + y = 64'h41200000001FFEFF; + z = 64'h380FFFF0000FFFFE; + ans = 64'hC1FBD59D6AD7BC32; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4005735\n"); + end + x = 64'hBFD0000000000001; y = 64'h434FFFFFFFFFFFFF; - z = 64'hB7FFFFF9FFFFFFFF; - ans = 64'h4549904CF9E46D4C; + z = 64'h4000000000000000; + ans = 64'hC32FFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -132483,12 +306712,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5675451\n"); + $fwrite(fp,"4006349\n"); end - x = 64'hC1300003FFFFC000; - y = 64'h316FFFFFFFE1FFFF; - z = 64'h47E00020FFFFFFFF; - ans = 64'h47E00020FFFFFFFF; + x = 64'hC0100020FFFFFFFE; + y = 64'hB3E00000000007FD; + z = 64'h0010000000000001; + ans = 64'h34000021000007FB; rn = 1; rz = 0; rm = 0; @@ -132530,10 +306759,2783 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5677465\n"); + $fwrite(fp,"4006963\n"); end - x = 64'hFFE0000000000001; - y = 64'h7FEFFFFFFFFFFFFE; + x = 64'hBFD0000000000001; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hB810000000003FFF; + ans = 64'hC330000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4007577\n"); + end + x = 64'h470F7FE000000000; + y = 64'h47F41FFFFFFFFFFE; + z = 64'hB0EFFFFFFFFFFBFF; + ans = 64'h4F13CF6BDFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4008191\n"); + end + x = 64'h0010000008000FFE; + y = 64'h7FE0000000000001; + z = 64'h4340000000000001; + ans = 64'h4340000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4008805\n"); + end + x = 64'hBFD0000000000001; + y = 64'h3FE416D104F099D3; + z = 64'h37F0000403FFFFFF; + ans = 64'hBFC416D104F099D4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4009419\n"); + end + x = 64'hB3BFFFFFFFFE0007; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hC020000002000001; + ans = 64'hF3BFFFFFFFFE0006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4010033\n"); + end + x = 64'hBFD0000000000001; + y = 64'h43C1DB4D2B6309FB; + z = 64'hBFE0000000000001; + ans = 64'hC3A1DB4D2B6309FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4010647\n"); + end + x = 64'h4D6FFFFFFD000000; + y = 64'h801020000000000F; + z = 64'hC02000000007FFFE; + ans = 64'hC02000000007FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4011261\n"); + end + x = 64'hBFD0000000000001; + y = 64'h7FF0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4011875\n"); + end + x = 64'h8390000001FDFFFF; + y = 64'h41D00000800001FE; + z = 64'h000FFFFFFFFFFFFF; + ans = 64'h8570000081FE020D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4012489\n"); + end + x = 64'hBFD0000000000001; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hC0303C0000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4013103\n"); + end + x = 64'h3FB0000000FFFFE0; + y = 64'h4D600000020003FE; + z = 64'h3FCFFFFA00000000; + ans = 64'h4D200000030003DE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4013717\n"); + end + x = 64'hB81FFFC200000000; + y = 64'h8000000000000000; + z = 64'h401FFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4014331\n"); + end + x = 64'hBFD0000000000001; + y = 64'hB65BFFFEFFFFFFFF; + z = 64'h3F60007FFFFFFFF7; + ans = 64'h3F60007FFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4014945\n"); + end + x = 64'h5E7FFFFFFFFFF900; + y = 64'h8000000000000001; + z = 64'h37FD80E342268EB7; + ans = 64'h37FD80E342268EB7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4015559\n"); + end + x = 64'hBFD0000000000001; + y = 64'h402FFFEFFFFFFFEE; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hC011FFF7FFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4016173\n"); + end + x = 64'hC342C8CD26F024C5; + y = 64'h3F8F6C22FCBDE80E; + z = 64'hFFD00000403FFFFE; + ans = 64'hFFD00000403FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4016787\n"); + end + x = 64'hBFD0000000000001; + y = 64'h8010000000000000; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4017401\n"); + end + x = 64'h000FFFFFFFF03FFE; + y = 64'hC03F8000000FFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4018015\n"); + end + x = 64'hBFD0000000000001; + y = 64'h8010000000000001; + z = 64'hBDE04000000001FF; + ans = 64'hBDE04000000001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4018629\n"); + end + x = 64'hC3E0FFFFFFFFFFF6; + y = 64'hC08FFFEFFFF7FFFE; + z = 64'hC25FFFFFFDBFFFFF; + ans = 64'h4480FFF77FF7BFF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4019243\n"); + end + x = 64'h38000000000100FF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h400FFFFFFFFFFFFE; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4019857\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC80FFFFFFFF00003; + z = 64'hCAD21510DDD222A9; + ans = 64'hCAD21510DDD22269; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4020471\n"); + end + x = 64'h43DFFFFEFFFFFFF8; + y = 64'hBCA0000000000000; + z = 64'h434FFFFFFFFFFFBF; + ans = 64'h434FFFFFFFFFFDBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4021085\n"); + end + x = 64'hBFD0000000000001; + y = 64'h402000000020FFFF; + z = 64'hBCAFFFFFFFFFFFFE; + ans = 64'hC000000000210001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4021699\n"); + end + x = 64'h47F0000000000000; + y = 64'hC00FF7FFFFBFFFFE; + z = 64'h406001FFFFFFFFF0; + ans = 64'hC80FF7FFFFBFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4022313\n"); + end + x = 64'hBFD0000000000001; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h3FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4022927\n"); + end + x = 64'hC26FF7FFFFFFFFDF; + y = 64'hBE8FFFFFFFFBFFFD; + z = 64'hFFF0000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4023541\n"); + end + x = 64'hBFD0000000000001; + y = 64'hBFD0000000000000; + z = 64'hB8C00000000020FF; + ans = 64'h3FB0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4024155\n"); + end + x = 64'hC08E000003FFFFFF; + y = 64'hF9D00000087FFFFE; + z = 64'hC02489F7E6A8C0A1; + ans = 64'h7A6E000013EFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4024769\n"); + end + x = 64'h43C3E49A1538B476; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h4000000000000000; + ans = 64'hC3B3E49A1538B475; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4025383\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC02FFFFFF7BFFFFF; + z = 64'hC01004003FFFFFFE; + ans = 64'hBF7001107FFFF600; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4025997\n"); + end + x = 64'h7FEFFFFFFFFEFFBF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h414FFFFEFFFFBFFF; + ans = 64'hFFDFFFFFFFFEFFBD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4026611\n"); + end + x = 64'hBFD0000000000001; + y = 64'hB52C7FFFFFFFFFFF; + z = 64'hBCA0000000000000; + ans = 64'hBCA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4027225\n"); + end + x = 64'h3FAFFFFFF80007FE; + y = 64'hBEAFE00000000001; + z = 64'h0011FFFFFFFFFFFE; + ans = 64'hBE6FDFFFF80807F7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4027839\n"); + end + x = 64'hBFD0000000000001; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h3FD0000000000000; + ans = 64'h3FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4028453\n"); + end + x = 64'hB80F000000000000; + y = 64'h35A00000403FFFFE; + z = 64'hFFE0000000000001; + ans = 64'hFFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4029067\n"); + end + x = 64'hBFD0000000000001; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hB806C0503D591458; + ans = 64'h3FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4029681\n"); + end + x = 64'h401FFC0000000800; + y = 64'h6566473ABD074EDC; + z = 64'h4047FFFF7FFFFFFE; + ans = 64'h65964471D5AFB384; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4030295\n"); + end + x = 64'hBFF0800000000100; + y = 64'hBFF0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h4000400000000081; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4030909\n"); + end + x = 64'hBFD0000000000001; + y = 64'h648FFFFFC00003FF; + z = 64'hD4400000FFFF7FFF; + ans = 64'hE46FFFFFC0000401; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4031523\n"); + end + x = 64'hC7F100000000003E; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3800EFFFFFFFFFFE; + ans = 64'h480100000000003D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4032137\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC1C08FFFFFFFFFFF; + z = 64'h8010000000000001; + ans = 64'h41A0900000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4032751\n"); + end + x = 64'h3FFFFFFEFFFEFFFF; + y = 64'h401003FFFFFDFFFF; + z = 64'hC0100FFFFFFF0000; + ans = 64'h400FEFFDFF77FF7A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4033365\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC000000000000001; + z = 64'h3CA0000000000001; + ans = 64'h3FE0000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4033979\n"); + end + x = 64'h41C00000001FFBFE; + y = 64'hC221001FFFFFFFFE; + z = 64'hC34FFFFFFFFFFFFF; + ans = 64'hC3F104200021FBFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4034593\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h7FD00004000FFFFF; + ans = 64'h7FD00004000FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4035207\n"); + end + x = 64'hC1C34B4A0CDF34C0; + y = 64'h47FFFFFFFFF7FFFE; + z = 64'h3FEFFFFFFFFFF03E; + ans = 64'hC9D34B4A0CDA61EC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4035821\n"); + end + x = 64'h47FB969279E5DD33; + y = 64'hC010000000000000; + z = 64'h3FEFFFFFFFFFFFFF; + ans = 64'hC81B969279E5DD33; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4036435\n"); + end + x = 64'hBFD0000000000001; + y = 64'hBFB1C24320BB5D4C; + z = 64'hBD6021FFFFFFFFFF; + ans = 64'h3F91C24320B9590D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4037049\n"); + end + x = 64'h3D3000001FEFFFFE; + y = 64'hC010000000000001; + z = 64'hC2F000000FF00000; + ans = 64'hC2F000000FF00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4037663\n"); + end + x = 64'hBFD0000000000001; + y = 64'hB7E0000201000000; + z = 64'h800FFFFFFFFFFFFF; + ans = 64'h37C0000201000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4038277\n"); + end + x = 64'h40500003FFFFFFF7; + y = 64'hB81B09507F18BE9F; + z = 64'h43100000000000C0; + ans = 64'h43100000000000C0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4038891\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC340000000000000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h4320000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4039505\n"); + end + x = 64'h47EFFFE03FFFFFFF; + y = 64'h80000800007FFFFF; + z = 64'hC01FFFFFFFFFFFFE; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4040119\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC340000000000001; + z = 64'hBFEFFFFBFEFFFFFF; + ans = 64'h4320000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4040733\n"); + end + x = 64'h381000001FF7FFFF; + y = 64'hBEFFFFE00000003F; + z = 64'h37F00000000407FF; + ans = 64'h37EFFF0001061080; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4041347\n"); + end + x = 64'hC00FFE01FFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3FDFFFFFFFFFFFFE; + ans = 64'h436FFE01FFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4041961\n"); + end + x = 64'hBFD0000000000001; + y = 64'h41DFFFFFFF7FFFFE; + z = 64'h3E1FBFFFF0000000; + ans = 64'hC1BFFFFFFF800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4042575\n"); + end + x = 64'hBE5F58FE19AABA16; + y = 64'hFFE0000000000000; + z = 64'h7B8ABA52ABAF7E78; + ans = 64'h7E4F58FE19AABBC2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4043189\n"); + end + x = 64'hBFD0000000000001; + y = 64'hB64000004FFFFFFF; z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; @@ -132577,12 +309579,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5679479\n"); + $fwrite(fp,"4043803\n"); end - x = 64'h8026FB49EB7370B2; - y = 64'h7FFFFFFFFFFFFFFF; - z = 64'hC1600200000003FF; - ans = 64'h7FFFFFFFFFFFFFFF; + x = 64'hBFF00800000001FF; + y = 64'hBEA0000FFFFFFFFF; + z = 64'h3CA00000003FFFF7; + ans = 64'h3EA00810081001FE; rn = 1; rz = 0; rm = 0; @@ -132624,12 +309626,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5681493\n"); + $fwrite(fp,"4044417\n"); end - x = 64'hBE90E49A299E9782; - y = 64'h3F5000000FC00000; - z = 64'h401FFFFFFC000004; - ans = 64'h401FFFFFFBFBC6DD; + x = 64'hBFD0000000000001; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'h7FD0000000000000; rn = 1; rz = 0; rm = 0; @@ -132671,12 +309673,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5683507\n"); + $fwrite(fp,"4045031\n"); end - x = 64'hFFE0000000000001; - y = 64'h800FFFFFFFFFFFFE; - z = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; + x = 64'h47F01FFBFFFFFFFF; + y = 64'hC3CFFFBFFF000000; + z = 64'hC010000000000000; + ans = 64'hCBD01FDBBF87001F; rn = 1; rz = 0; rm = 0; @@ -132718,12 +309720,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5685521\n"); + $fwrite(fp,"4045645\n"); end - x = 64'h40907FFFDFFFFFFE; - y = 64'h8010000000000001; - z = 64'hBFA03EFFFFFFFFFF; - ans = 64'hBFA03EFFFFFFFFFF; + x = 64'hBFD0000000000001; + y = 64'hFFF0000000000000; + z = 64'hCDF0083FFFFFFFFF; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -132765,12 +309767,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5687535\n"); + $fwrite(fp,"4046259\n"); end - x = 64'h403FFFFFFFFFFFFE; - y = 64'hBFFFFC0FFFFFFFFE; - z = 64'hC7E00000001F7FFE; - ans = 64'hC7E00000001F7FFE; + x = 64'hC1F0000001FFFFF8; + y = 64'hF000091FCAE1C2F2; + z = 64'h40700000000FBFFF; + ans = 64'h7200091FCCE2E6E3; rn = 1; rz = 0; rm = 0; @@ -132812,12 +309814,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5689549\n"); + $fwrite(fp,"4046873\n"); end - x = 64'hFFE0000000000001; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'hBFF0000000000001; - ans = 64'h7CA0000000000000; + x = 64'h380BFFFFFFFBFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h3FD0000000000000; + ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -132859,12 +309861,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5691563\n"); + $fwrite(fp,"4047487\n"); end - x = 64'hBE7DFFFFFFFFBFFF; - y = 64'hBFD0000000000001; - z = 64'h48A000000FFF7FFE; - ans = 64'h48A000000FFF7FFE; + x = 64'hBFD0000000000001; + y = 64'h4F5FFFEFFFFFEFFF; + z = 64'hBFEF00FFFFFFFFFF; + ans = 64'hCF3FFFEFFFFFF001; rn = 1; rz = 0; rm = 0; @@ -132906,199 +309908,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5693577\n"); + $fwrite(fp,"4048101\n"); end - x = 64'hC0C01F0000000000; - y = 64'h3FF0001FFF7FFFFF; - z = 64'hBE12DD4B694FB5D8; - ans = 64'hC0C01F203D7F0A5B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5695591\n"); - end - x = 64'hFFE0000000000001; - y = 64'hBFEFFFFFFFFFFFFF; - z = 64'h4340000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5697605\n"); - end - x = 64'h3F7451E3E906A160; - y = 64'hBFF0000000000000; - z = 64'h37E080000000003F; - ans = 64'hBF7451E3E906A160; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5699619\n"); - end - x = 64'hC34FFFDFFFFF7FFF; - y = 64'hC7FFFFFF7FFF7FFE; - z = 64'hBFDFFFFFFEFFF800; - ans = 64'h4B5FFFDF7FFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5701633\n"); - end - x = 64'hFFE0000000000001; - y = 64'hC000000000000001; - z = 64'hFFFFFFFFFFFFFFFE; + x = 64'h3FCFFFFFFDC00000; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h7FE00000001FFFDF; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -133141,105 +309955,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5703647\n"); + $fwrite(fp,"4048715\n"); end - x = 64'h243F9FFFFFFFFFFF; - y = 64'hC010000000000000; - z = 64'h401007FBFFFFFFFF; - ans = 64'h401007FBFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5705661\n"); - end - x = 64'h3F8003FFFFFFDFFF; - y = 64'h3FC81AD9D396573D; - z = 64'h43F0000FFFFFFFF0; - ans = 64'h43F0000FFFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5707675\n"); - end - x = 64'hFFE0000000000001; - y = 64'hC340000000000001; - z = 64'hBCAFFFFFFFFFFFFF; + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3957F80000000000; + z = 64'h7FF0000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -133282,12 +310002,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5709689\n"); + $fwrite(fp,"4049329\n"); end - x = 64'hC0210000000FFFFF; - y = 64'hFFE0000000000000; - z = 64'hC0F19E8F60E66EF1; - ans = 64'h7FF0000000000000; + x = 64'h80224267F356EFFA; + y = 64'h7FF1000003FFFFFF; + z = 64'h401040000000007F; + ans = 64'h7FF9000003FFFFFF; rn = 1; rz = 0; rm = 0; @@ -133329,12 +310049,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5711703\n"); + $fwrite(fp,"4049943\n"); end - x = 64'hBCA0000007FEFFFE; - y = 64'hC1F1000003FFFFFF; - z = 64'h3FE000007FFFFBFF; - ans = 64'h3FE000018FFFFCC7; + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h0000000000000000; + ans = 64'h8007FFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -133376,11 +310096,387 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5713717\n"); + $fwrite(fp,"4050557\n"); end - x = 64'hFFE0000000000001; - y = 64'hFFF0000000000001; - z = 64'h3FF0000000000001; + x = 64'h37EFFFBFFFFEFFFF; + y = 64'hB7FFDFFFFFFFFEFE; + z = 64'hC000000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4051171\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h427B3594CB0AE0F1; + ans = 64'h427B3594CB0AE0F1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4051785\n"); + end + x = 64'hB8100000037FFFFE; + y = 64'h4032B8ACAF198E6B; + z = 64'hC1AE1FFFFFFFFFFE; + ans = 64'hC1AE1FFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4052399\n"); + end + x = 64'h9EB000000020FFFF; + y = 64'h0010000000000001; + z = 64'h3CA0000000000001; + ans = 64'h3CA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4053013\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h402325F07518C19F; + z = 64'h3FAF0003FFFFFFFF; + ans = 64'hC012E7F06D18C19E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4053627\n"); + end + x = 64'hBFC0000000000140; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h41E0000000000030; + ans = 64'h41E0000000000030; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4054241\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hBF5579030AA5CAAA; + z = 64'h7FE0000000000001; + ans = 64'h7FE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4054855\n"); + end + x = 64'h45BC57DB7A30FEF8; + y = 64'hC1FFFFFFFDFFFFBF; + z = 64'h41DFFFFFFF800020; + ans = 64'hC7CC57DB786B8107; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4055469\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3CA0000000000000; + z = 64'hFFF0000000000001; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -133423,12 +310519,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5715731\n"); + $fwrite(fp,"4056083\n"); end - x = 64'h3F29E1BCF47D151E; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hAD2DB2FBA0FDA091; - ans = 64'hFFFFFFFFFFFFFFFE; + x = 64'h41DFFFFFFFE00001; + y = 64'h8000010000100000; + z = 64'hBFFFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -133470,12 +310566,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5717745\n"); + $fwrite(fp,"4056697\n"); end - x = 64'h800FFFBFFFF00000; - y = 64'hBFFE01FFFFFFFFFF; - z = 64'h422FFFFEFF7FFFFF; - ans = 64'h422FFFFEFF7FFFFF; + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h41E000000010007F; + ans = 64'h41E000000010007F; rn = 1; rz = 0; rm = 0; @@ -133517,12 +310613,1140 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5719759\n"); + $fwrite(fp,"4057311\n"); end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'h0010000000000000; + x = 64'h05084F7999D9CDC4; + y = 64'hBEBE0D041AA7AD4D; + z = 64'h401000007FFFFFFC; + ans = 64'h401000007FFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4057925\n"); + end + x = 64'h540FF80200000000; + y = 64'h3FD0000000000000; + z = 64'h001FFFFFFFFFFFFF; + ans = 64'h53EFF80200000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4058539\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hFFFDE9DA2A5BA63C; + z = 64'h479B42C807E21737; + ans = 64'hFFFDE9DA2A5BA63C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4059153\n"); + end + x = 64'h3E2FF7FF00000000; + y = 64'h3FD0000000000001; + z = 64'hBCAFFFFFBDFFFFFF; + ans = 64'h3E0FF7FE8000010A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4059767\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h001000200000000E; + z = 64'h434FFFFFFFFFFFFF; + ans = 64'h434FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4060381\n"); + end + x = 64'hC3CFDFFFFFFFFFFB; + y = 64'h401FFFFF800003FF; + z = 64'h3FFC31B98FE49BD5; + ans = 64'hC3FFDFFF808003F6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4060995\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFEFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4061609\n"); + end + x = 64'hBFEFFFFFFFC00040; + y = 64'h37FFFFFFF80000FE; + z = 64'hBFEFFFFFFFFFFFFE; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4062223\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3FE0000000000001; + z = 64'hC0100007FFFFEFFF; + ans = 64'hC0110007FFFFEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4062837\n"); + end + x = 64'hFFEFFFFE007FFFFF; + y = 64'hBFF00000040FFFFF; + z = 64'hC1A12616CF13226C; + ans = 64'h7FEFFFFE089FFF7B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4063451\n"); + end + x = 64'hD3744789209EB713; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h000FFFFFFFFFFFFE; + ans = 64'hD3744789209EB712; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4064065\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h802FFFFFFBFFFFF7; + z = 64'hC030001FFFFFFFFF; + ans = 64'hC030001FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4064679\n"); + end + x = 64'h43FFFFBFFFFF7FFF; + y = 64'h3FF0000000000000; + z = 64'hBAD007FFC0000000; + ans = 64'h43FFFFBFFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4065293\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h401F000000001FFF; + z = 64'h401FFFFFFFFFFFFE; + ans = 64'h40107FFFFFFFEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4065907\n"); + end + x = 64'h3CAFFFAFFFFFFFFF; + y = 64'h40C8BC8C8EDD1A1B; + z = 64'hBA8BBCC16EDFA2A4; + ans = 64'h3D88BC4EB77DB4D6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4066521\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4067135\n"); + end + x = 64'h480007FFFFFFFFFF; + y = 64'hC3E23B89425430FF; + z = 64'hBFE0000000000000; + ans = 64'hCBF244A706F55B16; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4067749\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h4000000000000000; + z = 64'hC80C200000000000; + ans = 64'hC80C200000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4068363\n"); + end + x = 64'hC3D000003FFFFFFA; + y = 64'hC001FBFFFFFFFFFF; + z = 64'hC3DFFFFF000003FE; + ans = 64'h43AFC00C7EFFDF94; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4068977\n"); + end + x = 64'hCDA0007FFFFF7FFE; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h0000000000000000; + ans = 64'hCDC0007FFFFF7FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4069591\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hB7E0000007FDFFFF; + z = 64'hF06BFFFFFFFFFDFF; + ans = 64'hF06BFFFFFFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4070205\n"); + end + x = 64'h3FC6375007C0E6CB; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hBF80100200000000; + ans = 64'h3FE5F70FFFC0E6CA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4070819\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3F800000000000FF; + z = 64'h4010000000000000; + ans = 64'h400FF80000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4071433\n"); + end + x = 64'hC2F505134A57C74A; + y = 64'hC4FDFFFDFFFFFFFE; + z = 64'h00036DB98B6B20DE; + ans = 64'h4803B4C0C561162F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4072047\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h4010000000000001; z = 64'hC340000000000000; - ans = 64'hC340000000000002; + ans = 64'hC340000000000001; rn = 1; rz = 0; rm = 0; @@ -133564,12 +311788,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5721773\n"); + $fwrite(fp,"4072661\n"); end - x = 64'hB7FFFFF80000001F; - y = 64'h001FFFFFFFFFFFFE; - z = 64'h800FFFFFFFFF07FF; - ans = 64'h800FFFFFFFFF07FF; + x = 64'hC1D000001003FFFE; + y = 64'hE41628388A474A48; + z = 64'hBFD0000000000001; + ans = 64'h65F62838A0750CDE; rn = 1; rz = 0; rm = 0; @@ -133611,7 +311835,1981 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5723787\n"); + $fwrite(fp,"4073275\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hBFBD1E150B87BBA9; + ans = 64'hC0107478542E1EED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4073889\n"); + end + x = 64'h403000080000FFFF; + y = 64'hC11FFFFFFFFF7FBF; + z = 64'h3FD0000007FFF000; + ans = 64'hC1600007F800BFDA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4074503\n"); + end + x = 64'h402442B011FC172E; + y = 64'h4340000000000000; + z = 64'hFFF0000000000001; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4075117\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h92E5F946438B34BB; + z = 64'h3D98249F431F8AF7; + ans = 64'h3D98249F431F8AF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4075731\n"); + end + x = 64'h7FFD8D2187349BAF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hBFAFFFFFEFFFFFEF; + ans = 64'h7FFD8D2187349BAF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4076345\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h403FE01FFFFFFFFE; + z = 64'h4000000000000001; + ans = 64'hC02BE01FFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4076959\n"); + end + x = 64'hB61FF07FFFFFFFFE; + y = 64'hC1F1BFFFFFFFFFFF; + z = 64'h9EE00007FFFFFDFE; + ans = 64'h3821B766FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4077573\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'hC010000000000001; + ans = 64'hFFCFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4078187\n"); + end + x = 64'h402FFFDFFFFFFFF0; + y = 64'h42B0000000204000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h42EFFFE000407FAF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4078801\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h3FF2000007FFFFFF; + ans = 64'hFFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4079415\n"); + end + x = 64'hBFBFFFFFFFFFFFC4; + y = 64'h001FFF4000000000; + z = 64'h3FFFFFBFFF7FFFFF; + ans = 64'h3FFFFFBFFF7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4080029\n"); + end + x = 64'hBFC3F41B293A86D3; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hFFEFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4080643\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hC0D1AADED1EB7CD5; + z = 64'hBFD007FFFFFDFFFE; + ans = 64'h40C1AABEC1EB7CD8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4081257\n"); + end + x = 64'h7FEFFFFFFFF7EFFE; + y = 64'h7FF0000000000001; + z = 64'hC1FFFF7FFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4081871\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hC05FFFFFFFE7FFFF; + z = 64'h3FFFFFFFFFFFFFFF; + ans = 64'h40507FFFFFF3FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4082485\n"); + end + x = 64'h7FEF0001FFFFFFFF; + y = 64'h5E388880C29ADC6B; + z = 64'hBFC05BC428DD59D2; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4083099\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC00FFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4083713\n"); + end + x = 64'h43FFFFFEFFFFFFDF; + y = 64'h3FD04007FFFFFFFE; + z = 64'h801FFFFFFFFFFFFE; + ans = 64'h43E040077DFFBFED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4084327\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h8000000000000001; + z = 64'h8010000000800400; + ans = 64'h8010000000800400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4084941\n"); + end + x = 64'h43D00000000000BF; + y = 64'hF9FCA451E6B538F5; + z = 64'hCD0EA8DC36585668; + ans = 64'hFDDCA451E6B53A4B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4085555\n"); + end + x = 64'h40600001FF000000; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC34FFFFFFFFFFFFE; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4086169\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h4030000000FFFFFB; + z = 64'h3CAFEFFFFFFFFDFF; + ans = 64'hC020000000FFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4086783\n"); + end + x = 64'h001FFBFFFFFFFFFB; + y = 64'h8010000000000000; + z = 64'hBFA00FDFFFFFFFFF; + ans = 64'hBFA00FDFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4087397\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3F900000000EFFFF; + z = 64'h3FEFFFFFFFFFFFFE; + ans = 64'h3FEFBFFFFFFFC3FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4088011\n"); + end + x = 64'h8005FBF65B4CBC10; + y = 64'h41D0015FA92DD7E1; + z = 64'h4EBFFFFFFE000002; + ans = 64'h4EBFFFFFFE000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4088625\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hBFFFFFFFFFFFFFFE; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4089239\n"); + end + x = 64'hBD7000000000207F; + y = 64'h8EA0080000001000; + z = 64'h8010000000000000; + ans = 64'h0C2008000000308F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4089853\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hBCA0000000000000; + z = 64'h80166B3DD617F693; + ans = 64'h3C8FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4090467\n"); + end + x = 64'hB81DAC55BF5BDFB4; + y = 64'hDCC38871CC23B0AF; + z = 64'h3CA0000007DFFFFF; + ans = 64'h54F21CD8DBE659FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4091081\n"); + end + x = 64'hA15FFFFFFF001FFF; + y = 64'hBCA0000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4091695\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h0000000000000088; + z = 64'hF9B000007FDFFFFF; + ans = 64'hF9B000007FDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4092309\n"); + end + x = 64'h43E00001F7FFFFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hB9E00000001FFFBF; + ans = 64'hC0A00001F7FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4092923\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h541FFFFFFE0001FE; + z = 64'h3FE0000000000000; + ans = 64'hD40FFFFFFE0001FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4093537\n"); + end + x = 64'h39700004000007FE; + y = 64'h3800000800400000; + z = 64'h3FDB4AD36E04AA09; + ans = 64'h3FDB4AD36E04AA09; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4094151\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hBFD0000000000001; + z = 64'hBFF0000000000000; + ans = 64'hBFEC000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4094765\n"); + end + x = 64'h43EFFFFE0000000E; + y = 64'hBFEFFFFFFFFFFE07; + z = 64'h8000000000000001; + ans = 64'hC3EFFFFDFFFFFE15; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4095379\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBFCFFFBFFFFF7FFF; + ans = 64'h3EE000001FFF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4095993\n"); + end + x = 64'hB87003FFFFFFFFFE; + y = 64'h402FFFFEFFEFFFFF; + z = 64'hC3EFFC00007FFFFF; + ans = 64'hC3EFFC00007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4096607\n"); + end + x = 64'h40F0000000100200; + y = 64'hBFE0000000000000; + z = 64'hC010000000000001; + ans = 64'hC0E0008000100200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4097221\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hC066FFFFFFFFFFFF; + z = 64'h3FDF4B5441BBD2DA; + ans = 64'h40571F4B5441BBD1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4097835\n"); + end + x = 64'h41F000001000000F; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h2000100003FFFFFE; + ans = 64'hC1F000001000000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4098449\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3FDF1F3616AA73E1; + z = 64'h3FD0000000000001; + ans = 64'h3F7C193D2AB1843F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4099063\n"); end $stop; end diff --git a/wally-pipelined/src/fpu/dev/fputop.sv b/wally-pipelined/src/fpu/dev/fputop.sv deleted file mode 100755 index b47a3319..00000000 --- a/wally-pipelined/src/fpu/dev/fputop.sv +++ /dev/null @@ -1,476 +0,0 @@ -`include "../../../config/rv64icfd/wally-config.vh" - -module fputop ( - input logic [2:0] FrmD, - input logic reset, - input logic clear, - input logic clk, - input logic [31:0] InstrD, - input logic [`XLEN-1:0] SrcAE, - input logic [`XLEN-1:0] SrcAW, - output logic [31:0] FSROutW, - output logic DivSqrtDoneE, - output logic FInvalInstrD, - output logic [`XLEN-1:0] FPUResultW); - - //NOTE: - //For readability and ease of modification, logic signals will be - //instantiated as they occur within the pipeline. This will keep local - //signals, modules, and combinational logic closely defined. - - //used for OSU DP-size hardware to wally XLEN interfacing - integer XLENDIFF; - assign XLENDIFF = `XLEN - 64; - integer XLENDIFFN; - assign XLENDIFFN = 63 - `XLEN; - - //#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*# - //BEGIN PIPELINE CONTROL LOGIC - // - - logic PipeEnableDE; - logic PipeEnableEM; - logic PipeEnableMW; - logic PipeClearDE; - logic PipeClearEM; - logic PipeClearMW; - - //temporarily assign pipe clear and enable signals - //to never flush & always be running - assign PipeClear = 1'b0; - assign PipeEnable = 1'b1; - always_comb begin - - PipeEnableDE = PipeEnable; - PipeEnableEM = PipeEnable; - PipeEnableMW = PipeEnable; - PipeClearDE = PipeClear; - PipeClearEM = PipeClear; - PipeClearMW = PipeClear; - - end - - // - //END PIPELINE CONTROL LOGIC - //#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*# - - //######################################### - //BEGIN DECODE STAGE - // - - //wally-spec D stage control logic signal instantiation - logic IllegalFPUInstrFaultD; - logic FRegWriteD; - logic [2:0] FResultSelD; - //logic [2:0] FrmD; - logic PD; - logic DivSqrtStartD; - logic [3:0] OpCtrlD; - logic WriteIntD; - - //top-level controller for FPU - fctrl ctrl (.Funct7D(InstrD[31:25]), .OpD(InstrD[6:0]), .Rs2D(InstrD[24:20]), .Rs1D(InstrD[19:15]), .FrmW(InstrD[14:12]), .WriteEnD(FRegWriteD), .DivSqrtStartD(DivSqrtStartD), .WriteSelD(FResultSelD), .OpCtrlD(OpCtrlD), .FmtD(PD), .WriteIntD(WriteIntD)); - - //instantiation of D stage regfile signals (includes some W stage signals - //for easy reference) - logic [2:0] FrmW; - logic WriteEnW; - logic [4:0] RdW, Rs1D, Rs2D, Rs3D; - logic [`XLEN-1:0] WriteDataW; - logic [`XLEN-1:0] ReadData1D, ReadData2D, ReadData3D; - - //regfile instantiation - freg3adr fpregfile (FrmW, reset, PipeClear, clk, RdW, WriteEnW, Rs1D, Rs2D, Rs3D, WriteDataW, ReadData1D, ReadData2D, ReadData3D); - - always_comb begin - FrmW = InstrD[14:12]; - end - - // - //END DECODE STAGE - //######################################### - - //***************************************** - //BEGIN D/E PIPE - // - - //wally-spec E stage control logic signal instantiation - logic FRegWriteE; - logic [2:0] FResultSelE; - logic [2:0] FrmE; - logic PE; - logic DivSqrtStartE; - logic [3:0] OpCtrlE; - - //instantiation of E stage regfile signals - logic [4:0] RdE; - logic [`XLEN-1:0] ReadData1E, ReadData2E, ReadData3E; - - //instantiation of E/M stage div/sqrt signals - logic DivSqrtDone, DivDenormM; - logic [63:0] DivResultM; - logic [4:0] DivFlagsM; - logic [63:0] DivOp1, DivOp2; - logic [2:0] DivFrm; - logic DivOpType; - logic DivP; - logic DivOvEn, DivUnEn; - logic DivStart; - - //instantiate E stage FMA signals here - - //instantiation of E stage add/cvt signals - logic [63:0] AddSumE, AddSumTcE; - logic [3:0] AddSelInvE; - logic [10:0] AddExpPostSumE; - logic AddCorrSignE, AddOp1NormE, AddOp2NormE, AddOpANormE, AddOpBNormE, AddInvalidE; - logic AddDenormInE, AddSwapE, AddNormOvflowE, AddSignAE; - logic [63:0] AddFloat1E, AddFloat2E; - logic [10:0] AddExp1DenormE, AddExp2DenormE, AddExponentE; - logic [63:0] AddOp1E, AddOp2E; - logic [2:0] AddRmE; - logic [3:0] AddOpTypeE; - logic AddPE, AddOvEnE, AddUnEnE; - - //instantiation of E stage cmp signals - logic [7:0] WE, XE; - logic ANaNE, BNaNE, AzeroE, BzeroE; - logic [63:0] CmpOp1E, CmpOp2E; - logic [1:0] CmpSelE; - - //instantiation of E/M stage fsgn signals (due to bypass logic) - logic [63:0] SgnOp1E, SgnOp2E; - logic [1:0] SgnOpCodeE, SgnOpCodeM; - logic [63:0] SgnResultE, SgnResultM; - logic [4:0] SgnFlagsE, SgnFlagsM; - - //***************** - //fpregfile D/E pipe registers - //***************** - flopenrc #(64) (clk, reset, PipeClearDE, PipeEnableDE, ReadData1D, ReadData1E); - flopenrc #(64) (clk, reset, PipeClearDE, PipeEnableDE, ReadData2D, ReadData2E); - flopenrc #(64) (clk, reset, PipeClearDE, PipeEnableDE, ReadData3D, ReadData3E); - - //***************** - //other D/E pipe registers - //***************** - flopenrc #(1) (clk, reset, PipeClearDE, PipeEnableDE, FRegWriteD, FRegWriteE); - flopenrc #(3) (clk, reset, PipeClearDE, PipeEnableDE, FResultsSelD, FResultsSelE); - flopenrc #(3) (clk, reset, PipeClearDE, PipeEnableDE, FrmD, FrmE); - flopenrc #(1) (clk, reset, PipeClearDE, PipeEnableDE, PD, PE); - flopenrc #(4) (clk, reset, PipeClearDE, PipeEnableDE, OpCtrlD, OpCtrlE); - flopenrc #(1) (clk, reset, PipeClearDE, PipeEnableDE, DivSqrtStartD, DivSqrtStartE); - - // - //END D/E PIPE - //***************************************** - - //######################################### - //BEGIN EXECUTION STAGE - // - - //fma1 (); - - //first and only instance of floating-point divider - fpdivsqrt (DivSqrtDone, DivResultM, DivFlagsM, DivDenormM, DivOp1, DivOp2, DivFrm, DivOpType, DivP, DivOvEn, DivUnEn, DivStart, reset, clk); - - //first of two-stage instance of floating-point add/cvt unit - fpaddcvt1 fpadd1 (AddSumE, AddSumTcE, AddSelInvE, AddExpPostSumE, AddCorrSignE, AddOp1NormE, AddOp2NormE, AddOpANormE, AddOpBNormE, AddInvalidE, AddDenormInE, AddConvertE, AddSwapE, AddNormOvflowE, AddSignAE, AddFloat1E, AddFloat2E, AddExp1DenormE, AddExp2DenormE, AddExponentE, AddOp1E, AddOp2E, AddRmE, AddOpTypeE, AddPE, AddOvEnE, AddUnEnE); - - //first of two-stage instance of floating-point comparator - fpcmp1 fpcmp1 (WE, XE, ANaNE, BNaNE, AzeroE, BzeroE, CmpOp1E, CmpOp2E, CmpSelE); - - //first and only instance of floating-point sign converter - fpusgn fpsgn (SgnOpCodeE, SgnResultE, SgnFlagsE, SgnOp1, SgnOp2); - - //interface between XLEN size datapath and double-precision sized - //floating-point results - // - //define offsets for LSB zero extension or truncation - always_comb begin - - //truncate to 64 bits - //(causes warning during compilation - case never reached) - if(`XLEN > 64) begin - DivOp1 <= ReadData1E[`XLEN:`XLEN-64]; - DivOp2 <= ReadData2E[`XLEN:`XLEN-64]; - AddOp1E <= ReadData1E[`XLEN:`XLEN-64]; - AddOp2E <= ReadData2E[`XLEN:`XLEN-64]; - CmpOp1E <= ReadData1E[`XLEN:`XLEN-64]; - CmpOp2E <= ReadData2E[`XLEN:`XLEN-64]; - SgnOp1E <= ReadData1E[`XLEN:`XLEN-64]; - SgnOp2E <= ReadData2E[`XLEN:`XLEN-64]; - end - //zero extend to 64 bits - else begin - DivOp1 <= {ReadData1E,{64-`XLEN{1'b0}}}; - DivOp2 <= {ReadData2E,{64-`XLEN{1'b0}}}; - AddOp1E <= {ReadData1E,{64-`XLEN{1'b0}}}; - AddOp2E <= {ReadData2E,{64-`XLEN{1'b0}}}; - CmpOp1E <= {ReadData1E,{64-`XLEN{1'b0}}}; - CmpOp2E <= {ReadData2E,{64-`XLEN{1'b0}}}; - SgnOp1E <= {ReadData1E,{64-`XLEN{1'b0}}}; - SgnOp2E <= {ReadData2E,{64-`XLEN{1'b0}}}; - end - - //assign op codes - AddOpTypeE[3:0] <= OpCtrlE[3:0]; - CmpSelE[1:0] <= OpCtrlE[1:0]; - DivOpType <= OpCtrlE[0]; - SgnOpCodeE[1:0] <= OpCtrlE[1:0]; - - end - - //E stage control signal interfacing between wally spec and OSU fp hardware - //op codes - - // - //END EXECUTION STAGE - //######################################### - - //***************************************** - //BEGIN E/M PIPE - // - - //wally-spec M stage control logic signal instantiation - logic FRegWriteM; - logic [2:0] FResultSelM; - logic [2:0] FrmM; - logic PM; - logic [3:0] OpCtrlM; - - //instantiate M stage FMA signals here - - //instantiation of M stage regfile signals - logic [4:0] RdM; - logic [`XLEN-1:0] ReadData1M, ReadData2M, ReadData3M; - - //instantiation of M stage add/cvt signals - logic [63:0] AddResultM; - logic [4:0] AddFlagsM; - logic AddDenormM; - logic [63:0] AddSumM, AddSumTcM; - logic [3:0] AddSelInvM; - logic [10:0] AddExpPostSumM; - logic AddCorrSignM, AddOp1NormM, AddOp2NormM, AddOpANormM, AddOpBNormM, AddInvalidM; - logic AddDenormInM, AddSwapM, AddNormOvflowM, AddSignAM; - logic [63:0] AddFloat1M, AddFloat2M; - logic [10:0] AddExp1DenormM, AddExp2DenormM, AddExponentM; - logic [63:0] AddOp1M, AddOp2M; - logic [2:0] AddRmM; - logic [3:0] AddOpTypeM; - logic AddPM, AddOvEnM, AddUnEnM; - - //instantiation of M stage cmp signals - logic CmpInvalidM; - logic [1:0] CmpFCCM; - logic [7:0] WM, XM; - logic ANaNM, BNaNM, AzeroM, BzeroM; - logic [63:0] CmpOp1M, CmpOp2M; - logic [1:0] CmpSelM; - - //***************** - //fma E/M pipe registers - //***************** - - //***************** - //fpadd E/M pipe registers - //***************** - flopenrc #(64) (clk, reset, PipeClearEM, PipeEnableEM, AddSumE, AddSumM); - flopenrc #(64) (clk, reset, PipeClearEM, PipeEnableEM, AddSumTcE, AddSumTcM); - flopenrc #(4) (clk, reset, PipeClearEM, PipeEnableEM, AddSelInvE, AddSelInvM); - flopenrc #(11) (clk, reset, PipeClearEM, PipeEnableEM, AddExpPostSumE, AddExpPostSumM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddCorrSignE, AddCorrSignM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddOp1NormE, AddOp1NormM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddOp2NormE, AddOp2NormM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddOpANormE, AddOpANormM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddOpBNormE, AddOpBNormM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddInvalidE, AddInvalidM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddDenormInE, AddDenormInM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddConvertE, AddConvertM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddSwapE, AddSwapM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddNormOvflowE, AddNormOvflowM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddSignAE, AddSignM); - flopenrc #(64) (clk, reset, PipeClearEM, PipeEnableEM, AddFloat1E, AddFloat1M); - flopenrc #(64) (clk, reset, PipeClearEM, PipeEnableEM, AddFloat2E, AddFloat2M); - flopenrc #(11) (clk, reset, PipeClearEM, PipeEnableEM, AddExp1DenormE, AddExp1DenormM); - flopenrc #(11) (clk, reset, PipeClearEM, PipeEnableEM, AddExp2DenormE, AddExp2DenormM); - flopenrc #(11) (clk, reset, PipeClearEM, PipeEnableEM, AddExponentE, AddExponentM); - flopenrc #(64) (clk, reset, PipeClearEM, PipeEnableEM, AddOp1E, AddOp1M); - flopenrc #(64) (clk, reset, PipeClearEM, PipeEnableEM, AddOp2E, AddOp2M); - flopenrc #(3) (clk, reset, PipeClearEM, PipeEnableEM, AddRmE, AddRmM); - flopenrc #(4) (clk, reset, PipeClearEM, PipeEnableEM, AddOpTypeE, AddOpTypeM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddPE, AddPM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddOvEnE, AddOvEnM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AddUnEnE, AddUnEnM); - - //***************** - //fpcmp E/M pipe registers - //***************** - flopenrc #(8) (clk, reset, PipeClearEM, PipeEnableEM, WE, WM); - flopenrc #(8) (clk, reset, PipeClearEM, PipeEnableEM, XE, XM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, ANaNE, ANaNM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, BNaNE, BNaNM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, AzeroE, AzeroM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, BzeroE, BzeroM); - flopenrc #(64) (clk, reset, PipeClearEM, PipeEnableEM, CmpOp1E, CmpOp1M); - flopenrc #(64) (clk, reset, PipeClearEM, PipeEnableEM, CmpOp2E, CmpOp2M); - flopenrc #(2) (clk, reset, PipeClearEM, PipeEnableEM, CmpSelE, CmpSelM); - - //put this in for the event we want to delay fsgn - will otherwise bypass - //***************** - //fpsgn E/M pipe registers - //***************** - flopenrc #(2) (clk, reset, PipeClearEM, PipeEnableEM, SgnOpCodeE, SgnOpCodeM); - flopenrc #(64) (clk, reset, PipeClearEM, PipeEnableEM, SgnResultE, SgnResultM); - flopenrc #(5) (clk, reset, PipeClearEM, PipeEnableEM, SgnFlagsE, SgnFlagsM); - - //***************** - //other E/M pipe registers - //***************** - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, FRegWriteE, FRegWriteM); - flopenrc #(3) (clk, reset, PipeClearEM, PipeEnableEM, FResultsSelE, FResultsSelM); - flopenrc #(3) (clk, reset, PipeClearEM, PipeEnableEM, FrmE, FrmM); - flopenrc #(1) (clk, reset, PipeClearEM, PipeEnableEM, PE, PM); - flopenrc #(4) (clk, reset, PipeClearEM, PipeEnableEM, OpCtrlE, OpCtrlM); - - // - //END E/M PIPE - //***************************************** - - //######################################### - //BEGIN MEMORY STAGE - // - - //fma2 (); - - //second instance of two-stage floating-point add/cvt unit - fpaddcvt2 fpadd2 (AddResultM, AddFlagsM, AddDenormM, AddSumM, AddSumTcM, AddSelInvM, AddExpPostSumM, AddCorrSignM, AddOp1NormM, AddOp2NormM, AddOpANormM, AddOpBNormM, AddInvalidM, AddDenormInM, AddConvertM, AddSwapM, AddNormOvflowM, AddSignAM, AddFloat1M, AddFloat2M, AddExp1DenormM, AddExp2DenormM, AddExponentM, AddOp1M, AddOp2M, AddRmM, AddOpTypeM, AddPM, AddOvEnM, AddUnEnM); - - //second instance of two-stage floating-point comparator - fpcmp2 fpcmp2 (CmpInvalidM, CmpFCCM, ANaNM, BNaNM, AzeroM, BzeroM, WM, XM, CmpSelM, CmpOp1M, CmpOp2M); - - // - //END MEMORY STAGE - //######################################### - - - //***************************************** - //BEGIN M/W PIPE - // - - //wally-spec W stage control logic signal instantiation - logic FRegWriteW; - logic [2:0] FResultSelW; - logic PW; - - //instantiate W stage fma signals here - - //instantiation of W stage div/sqrt signals - logic DivDenormW; - logic [63:0] DivResultW; - logic [4:0] DivFlagsW; - - //instantiation of W stage regfile signals - logic [`XLEN-1:0] ReadData1W, ReadData2W, ReadData3W; - - //instantiation of W stage add/cvt signals - logic [63:0] AddResultW; - logic [4:0] AddFlagsW; - logic AddDenormW; - - //instantiation of W stage cmp signals - logic CmpInvalidW; - logic [1:0] CmpFCCW; - - //***************** - //fma M/W pipe registers - //***************** - - //***************** - //fpdiv M/W pipe registers - //***************** - flopenrc #(64) (clk, reset, PipeClearMW, PipeEnableMW, DivResultM, DivResultW); - flopenrc #(5) (clk, reset, PipeClearMW, PipeEnableMW, DivFlagsM, DivFlagsW); - flopenrc #(1) (clk, reset, PipeClearMW, PipeEnableMW, DivDenormM, DivDenormW); - - //***************** - //fpadd M/W pipe registers - //***************** - flopenrc #(64) (clk, reset, PipeClearMW, PipeEnableMW, AddResultM, AddResultW); - flopenrc #(5) (clk, reset, PipeClearMW, PipeEnableMW, AddFlagsM, AddFlagsW); - flopenrc #(1) (clk, reset, PipeClearMW, PipeEnableMW, AddDenormM, AddDenormW); - - //***************** - //fpcmp M/W pipe registers - //***************** - flopenrc #(1) (clk, reset, PipeClearMW, PipeEnableMW, CmpInvalidM, CmpInvalidW); - flopenrc #(2) (clk, reset, PipeClearMW, PipeEnableMW, CmpFCCM, CmpFCCW); - - //***************** - //fpsgn M/W pipe registers - //***************** - flopenrc #(64) (clk, reset, PipeClearMW, PipeEnableMw, SgnResultM, SgnResultW); - flopenrc #(5) (clk, reset, PipeClearMw, PipeEnableMw, SgnFlagsM, SgnFlagsW); - - //***************** - //other M/W pipe registers - //***************** - flopenrc #(1) (clk, reset, PipeClearMW, PipeEnableMW, FRegWriteM, FRegWriteW); - flopenrc #(3) (clk, reset, PipeClearMW, PipeEnableMW, FResultsSelM, FResultsSelW); - flopenrc #(1) (clk, reset, PipeClearMW, PipeEnableMW, PM, PW); - - ////END M/W PIPE - //***************************************** - - - //######################################### - //BEGIN WRITEBACK STAGE - // - - //flag signal mux via in-line ternaries - logic [4:0] FPUFlagsW; - //if bit 2 is active set to sign flags - otherwise: - //iff bit one is high - if bit zero is active set to fma flags - otherwise - //set to cmp flags - //iff bit one is low - if bit zero is active set to add/cvt flags - otherwise - //set to div/sqrt flags - assign FPUFlagsW = (FResultSelW[2]) ? (SgnFlagsW) : ( - (FResultSelW[1]) ? - ( (FResultSelW[0]) ? (5'b00000) : ({CmpInvalidW,4'b0000}) ) - : ( (FResultSelW[0]) ? (AddFlagsW) : (DivFlagsW) ) - ); - - //result mux via in-line ternaries - logic [63:0] FPUResultDirW; - //the uses the same logic as for flag signals - assign FPUResultDirW = (FResultSelW[2]) ? (SgnResultW) : ( - (FResultSelW[1]) ? - ( (FResultSelW[0]) ? (64'b0) : ({62'b0,CmpFCCW}) ) - : ( (FResultSelW[0]) ? (AddResultW) : (DivResultW) ) - ); - - //interface between XLEN size datapath and double-precision sized - //floating-point results - // - //define offsets for LSB zero extension or truncation - always_comb begin - - //zero extension - if(`XLEN > 64) begin - FPUResultW <= {FPUResultDirW,{XLENDIFF{1'b0}}}; - end - //truncate - else begin - FPUResultW <= FPUResultDirW[63:64-`XLEN]; - end - - end - - // - //END WRITEBACK STAGE - //######################################### - - - -endmodule diff --git a/wally-pipelined/src/wally/wallypipelinedhart.sv b/wally-pipelined/src/wally/wallypipelinedhart.sv index 1bb1b48c..28442c39 100644 --- a/wally-pipelined/src/wally/wallypipelinedhart.sv +++ b/wally-pipelined/src/wally/wallypipelinedhart.sv @@ -88,8 +88,13 @@ module wallypipelinedhart ( logic DivBusyE; logic [4:0] SetFflagsM; logic [2:0] FRM_REGW; + logic DivDoneW; logic FloatRegWriteW; logic SquashSCW; + logic [31:0] FSROutW; + logic DivSqrtDoneE; + logic FInvalInstrD; + logic [`XLEN-1:0] FPUResultW; // memory management unit signals logic ITLBWriteF, DTLBWriteM; @@ -144,16 +149,17 @@ module wallypipelinedhart ( muldiv mdu(.*); // multiply and divide unit - /* fpu fpu(.*); // floating point unit - */ + hazard hzu(.*); // global stall and flush control // Priveleged block operates in M and W stages, handling CSRs and exceptions privileged priv(.*); + + fpu fpu(.*); // floating point unit // add FPU here, with SetFflagsM, FRM_REGW // presently stub out SetFlagsM and FloatRegWriteW - assign SetFflagsM = 0; - assign FloatRegWriteW = 0; + //assign SetFflagsM = 0; + //assign FloatRegWriteW = 0; endmodule diff --git a/wally-pipelined/testbench/testbench-imperas.sv b/wally-pipelined/testbench/testbench-imperas.sv index b9822c4d..651c422d 100644 --- a/wally-pipelined/testbench/testbench-imperas.sv +++ b/wally-pipelined/testbench/testbench-imperas.sv @@ -360,7 +360,7 @@ string tests32i[] = { if (`A_SUPPORTED) tests = {tests, tests64a}; end // tests = {tests64a, tests}; - tests = {tests, tests64p}; + // tests = {tests, tests64p}; end else begin // RV32 // *** add the 32 bit bp tests tests = {tests32i};